@module-federation/webpack-bundler-runtime 1.0.0-canary.1

package/index.cjs.js

@@ -0,0 +1,4053 @@
+'use strict';
+
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+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);
+}
+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 : "";
+}
+function isDebugMode$1() {
+    return Boolean("");
+}
+function isBrowserEnv$1() {
+    return typeof window !== "undefined";
+}
+var LOG_CATEGORY = "[ Federation Runtime ]";
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function assert(condition, msg) {
+    if (!condition) {
+        error(msg);
+    }
+}
+function error(msg) {
+    throw new Error("".concat(LOG_CATEGORY, ": ").concat(msg));
+}
+function warn(msg) {
+    console.warn("".concat(LOG_CATEGORY, ": ").concat(msg));
+}
+function addUniqueItem(arr, item) {
+    if (arr.findIndex(function(name) {
+        return name === item;
+    }) === -1) {
+        arr.push(item);
+    }
+    return arr;
+}
+function getFMId(remoteInfo) {
+    if ("version" in remoteInfo && remoteInfo.version) {
+        return "".concat(remoteInfo.name, ":").concat(remoteInfo.version);
+    } else if ("entry" in remoteInfo && remoteInfo.entry) {
+        return "".concat(remoteInfo.name, ":").concat(remoteInfo.entry);
+    } else {
+        return "".concat(remoteInfo.name);
+    }
+}
+function isRemoteInfoWithEntry(remote) {
+    return typeof remote.entry !== "undefined";
+}
+function isPureRemoteEntry(remote) {
+    return remote.entry.endsWith(".js");
+}
+function safeWrapper(callback, disableWarn) {
+    return _safeWrapper.apply(this, arguments);
+}
+function _safeWrapper() {
+    _safeWrapper = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _async_to_generator$1(function(callback, disableWarn) {
+        var res, e;
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        callback()
+                    ];
+                case 1:
+                    res = _state.sent();
+                    return [
+                        2,
+                        res
+                    ];
+                case 2:
+                    e = _state.sent();
+                    !disableWarn && warn(e);
+                    return [
+                        2
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _safeWrapper.apply(this, arguments);
+}
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function safeToString$1(info) {
+    try {
+        return JSON.stringify(info, null, 2);
+    } catch (e) {
+        return "";
+    }
+}
+function isObject(val) {
+    return val && typeof val === "object";
+}
+var objectToString = Object.prototype.toString;
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isPlainObject(val) {
+    return objectToString.call(val) === "[object Object]";
+}
+function isStaticResourcesEqual(url1, url2) {
+    var REG_EXP = /^(https?:)?\/\//i;
+    // Convert both url1 and url2 to relative paths
+    var relativeUrl1 = url1.replace(REG_EXP, "").replace(/\/$/, "");
+    var relativeUrl2 = url2.replace(REG_EXP, "").replace(/\/$/, "");
+    // Determines whether relative paths are equal
+    return relativeUrl1 === relativeUrl2;
+}
+var _nativeGlobal___FEDERATION__, _nativeGlobal___FEDERATION__1, _nativeGlobal___FEDERATION__2, _nativeGlobal___FEDERATION__3, _nativeGlobal___FEDERATION__4, _nativeGlobal___FEDERATION__5, _nativeGlobal___FEDERATION__6;
+// export const nativeGlobal: typeof global = new Function('return this')();
+var nativeGlobal = new Function("return this")();
+// Avoid being windowed by some microfront end frameworks, but sandbox escapes due to reuse policies
+// The sandbox in the microfront does not copy the value of configurable
+// If no loading content exists on the global object, the loading object is defined
+if (!Object.hasOwnProperty.call(globalThis, "__GLOBAL_LOADING_REMOTE_ENTRY__")) {
+    Object.defineProperty(globalThis, "__GLOBAL_LOADING_REMOTE_ENTRY__", {
+        value: {},
+        configurable: false
+    });
+}
+var globalLoading = globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__;
+//
+if (nativeGlobal.__VMOK__) {
+    nativeGlobal.__FEDERATION__ = nativeGlobal.__VMOK__;
+} else if (!nativeGlobal.__FEDERATION__) {
+    nativeGlobal.__FEDERATION__ = {
+        __GLOBAL_PLUGIN__: [],
+        __INSTANCES__: [],
+        moduleInfo: {},
+        __SHARE__: {},
+        __MANIFEST_LOADING__: {},
+        __SHARE_SCOPE_LOADING__: {},
+        __PRELOADED_MAP__: new Map()
+    };
+    nativeGlobal.__VMOK__ = nativeGlobal.__FEDERATION__;
+}
+var ___GLOBAL_PLUGIN__;
+(___GLOBAL_PLUGIN__ = (_nativeGlobal___FEDERATION__ = nativeGlobal.__FEDERATION__).__GLOBAL_PLUGIN__) != null ? ___GLOBAL_PLUGIN__ : _nativeGlobal___FEDERATION__.__GLOBAL_PLUGIN__ = [];
+var ___INSTANCES__;
+(___INSTANCES__ = (_nativeGlobal___FEDERATION__1 = nativeGlobal.__FEDERATION__).__INSTANCES__) != null ? ___INSTANCES__ : _nativeGlobal___FEDERATION__1.__INSTANCES__ = [];
+var _moduleInfo;
+(_moduleInfo = (_nativeGlobal___FEDERATION__2 = nativeGlobal.__FEDERATION__).moduleInfo) != null ? _moduleInfo : _nativeGlobal___FEDERATION__2.moduleInfo = {};
+var ___SHARE__;
+(___SHARE__ = (_nativeGlobal___FEDERATION__3 = nativeGlobal.__FEDERATION__).__SHARE__) != null ? ___SHARE__ : _nativeGlobal___FEDERATION__3.__SHARE__ = {};
+var ___MANIFEST_LOADING__;
+(___MANIFEST_LOADING__ = (_nativeGlobal___FEDERATION__4 = nativeGlobal.__FEDERATION__).__MANIFEST_LOADING__) != null ? ___MANIFEST_LOADING__ : _nativeGlobal___FEDERATION__4.__MANIFEST_LOADING__ = {};
+var ___SHARE_SCOPE_LOADING__;
+(___SHARE_SCOPE_LOADING__ = (_nativeGlobal___FEDERATION__5 = nativeGlobal.__FEDERATION__).__SHARE_SCOPE_LOADING__) != null ? ___SHARE_SCOPE_LOADING__ : _nativeGlobal___FEDERATION__5.__SHARE_SCOPE_LOADING__ = {};
+var ___PRELOADED_MAP__;
+(___PRELOADED_MAP__ = (_nativeGlobal___FEDERATION__6 = nativeGlobal.__FEDERATION__).__PRELOADED_MAP__) != null ? ___PRELOADED_MAP__ : _nativeGlobal___FEDERATION__6.__PRELOADED_MAP__ = new Map();
+var Global = {
+    get __FEDERATION__ () {
+        var globalThisVal = new Function("return globalThis")();
+        return globalThisVal.__FEDERATION__;
+    }
+};
+function getGlobalFederationInstance(name, version) {
+    var buildId = getBuilderId();
+    return Global.__FEDERATION__.__INSTANCES__.find(function(GMInstance) {
+        if (buildId && GMInstance.options.id === getBuilderId()) {
+            return true;
+        }
+        if (GMInstance.options.name === name && !version) {
+            return true;
+        }
+        if (GMInstance.options.name === name && version && GMInstance.options.version === version) {
+            return true;
+        }
+        return false;
+    });
+}
+function setGlobalFederationInstance(FederationInstance) {
+    Global.__FEDERATION__.__INSTANCES__.push(FederationInstance);
+}
+function getGlobalFederationConstructor() {
+    return Global.__FEDERATION__.__DEBUG_CONSTRUCTOR__;
+}
+function setGlobalFederationConstructor(FederationConstructor) {
+    if (isDebugMode$1()) {
+        Global.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
+        Global.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "1.0.0-canary.1";
+    }
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function getInfoWithoutType(target, key, getModuleInfoHook) {
+    var res;
+    if (target[key]) {
+        res = {
+            value: target[key],
+            key: key
+        };
+    } else {
+        res = {
+            value: undefined,
+            key: key
+        };
+    }
+    if (getModuleInfoHook) {
+        var hookRes = getModuleInfoHook(target, key);
+        res = hookRes || res;
+    }
+    return res;
+}
+var getGlobalSnapshot = function() {
+    return Global.__FEDERATION__.moduleInfo;
+};
+var getTargetSnapshotInfoByModuleInfo = function(moduleInfo, snapshot, getModuleInfoHook) {
+    // remote include in hostSnapshot
+    var moduleKey = getFMId(moduleInfo);
+    var getModuleInfo = getInfoWithoutType(snapshot, moduleKey, getModuleInfoHook).value;
+    // remoteSnapshot may don't include version
+    if (getModuleInfo && !getModuleInfo.version && "version" in moduleInfo && moduleInfo["version"]) {
+        getModuleInfo.version = moduleInfo["version"];
+    }
+    if (getModuleInfo) {
+        return getModuleInfo;
+    }
+    // remote don't include in hostSnapshot
+    // deploy micro app snapshot
+    if ("version" in moduleInfo && moduleInfo["version"]) {
+        var version = moduleInfo.version, resModuleInfo = _object_without_properties_loose(moduleInfo, [
+            "version"
+        ]);
+        var moduleKeyWithoutVersion = getFMId(resModuleInfo);
+        var getModuleInfoWithoutVersion = getInfoWithoutType(Global.__FEDERATION__.moduleInfo, moduleKeyWithoutVersion, getModuleInfoHook).value;
+        if ((getModuleInfoWithoutVersion == null ? void 0 : getModuleInfoWithoutVersion.version) === version) {
+            return getModuleInfoWithoutVersion;
+        }
+    }
+    return;
+};
+var getGlobalSnapshotInfoByModuleInfo = function(moduleInfo, extraOptions) {
+    return getTargetSnapshotInfoByModuleInfo(moduleInfo, Global.__FEDERATION__.moduleInfo, extraOptions == null ? void 0 : extraOptions.getModuleInfoHook);
+};
+var setGlobalSnapshotInfoByModuleInfo = function(remoteInfo, moduleDetailInfo) {
+    var moduleKey = getFMId(remoteInfo);
+    Global.__FEDERATION__.moduleInfo[moduleKey] = moduleDetailInfo;
+    return Global.__FEDERATION__.moduleInfo;
+};
+var getRemoteEntryExports = function(name, globalName) {
+    var remoteEntryKey = globalName || "__FEDERATION_".concat(name, ":custom__");
+    var entryExports = globalThis[remoteEntryKey];
+    return {
+        remoteEntryKey: remoteEntryKey,
+        entryExports: entryExports
+    };
+};
+// global hooks
+var registerGlobalPlugins = function(plugins) {
+    var __GLOBAL_PLUGIN__ = Global.__FEDERATION__.__GLOBAL_PLUGIN__;
+    plugins.forEach(function(plugin) {
+        if (__GLOBAL_PLUGIN__.findIndex(function(p) {
+            return p.name === plugin.name;
+        }) === -1) {
+            __GLOBAL_PLUGIN__.push(plugin);
+        } else {
+            warn("The plugin ".concat(plugin.name, " has been registered."));
+        }
+    });
+};
+var getGlobalHostPlugins = function() {
+    return Global.__FEDERATION__.__GLOBAL_PLUGIN__;
+};
+var getPreloaded = function(id) {
+    return Global.__FEDERATION__.__PRELOADED_MAP__.get(id);
+};
+var setPreloaded = function(id) {
+    return Global.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
+};
+var DEFAULT_SCOPE = "default";
+var DEFAULT_REMOTE_TYPE = "global";
+// those constants are based on https://www.rubydoc.info/gems/semantic_range/3.0.0/SemanticRange#BUILDIDENTIFIER-constant
+var buildIdentifier = "[0-9A-Za-z-]+";
+var build = "(?:\\+(".concat(buildIdentifier, "(?:\\.").concat(buildIdentifier, ")*))");
+var numericIdentifier = "0|[1-9]\\d*";
+var numericIdentifierLoose = "[0-9]+";
+var nonNumericIdentifier = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+var preReleaseIdentifierLoose = "(?:".concat(numericIdentifierLoose, "|").concat(nonNumericIdentifier, ")");
+var preReleaseLoose = "(?:-?(".concat(preReleaseIdentifierLoose, "(?:\\.").concat(preReleaseIdentifierLoose, ")*))");
+var preReleaseIdentifier = "(?:".concat(numericIdentifier, "|").concat(nonNumericIdentifier, ")");
+var preRelease = "(?:-(".concat(preReleaseIdentifier, "(?:\\.").concat(preReleaseIdentifier, ")*))");
+var xRangeIdentifier = "".concat(numericIdentifier, "|x|X|\\*");
+var xRangePlain = "[v=\\s]*(".concat(xRangeIdentifier, ")(?:\\.(").concat(xRangeIdentifier, ")(?:\\.(").concat(xRangeIdentifier, ")(?:").concat(preRelease, ")?").concat(build, "?)?)?");
+var hyphenRange = "^\\s*(".concat(xRangePlain, ")\\s+-\\s+(").concat(xRangePlain, ")\\s*$");
+var mainVersionLoose = "(".concat(numericIdentifierLoose, ")\\.(").concat(numericIdentifierLoose, ")\\.(").concat(numericIdentifierLoose, ")");
+var loosePlain = "[v=\\s]*".concat(mainVersionLoose).concat(preReleaseLoose, "?").concat(build, "?");
+var gtlt = "((?:<|>)?=?)";
+var comparatorTrim = "(\\s*)".concat(gtlt, "\\s*(").concat(loosePlain, "|").concat(xRangePlain, ")");
+var loneTilde = "(?:~>?)";
+var tildeTrim = "(\\s*)".concat(loneTilde, "\\s+");
+var loneCaret = "(?:\\^)";
+var caretTrim = "(\\s*)".concat(loneCaret, "\\s+");
+var star = "(<|>)?=?\\s*\\*";
+var caret = "^".concat(loneCaret).concat(xRangePlain, "$");
+var mainVersion = "(".concat(numericIdentifier, ")\\.(").concat(numericIdentifier, ")\\.(").concat(numericIdentifier, ")");
+var fullPlain = "v?".concat(mainVersion).concat(preRelease, "?").concat(build, "?");
+var tilde = "^".concat(loneTilde).concat(xRangePlain, "$");
+var xRange = "^".concat(gtlt, "\\s*").concat(xRangePlain, "$");
+var comparator = "^".concat(gtlt, "\\s*(").concat(fullPlain, ")$|^$");
+// copy from semver package
+var 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() {
+    for(var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++){
+        fns[_key] = arguments[_key];
+    }
+    return function(x) {
+        return fns.reduce(function(v, f) {
+            return f(v);
+        }, x);
+    };
+}
+function extractComparator(comparatorString) {
+    return comparatorString.match(parseRegex(comparator));
+}
+function combineVersion(major, minor, patch, preRelease) {
+    var mainVersion = "".concat(major, ".").concat(minor, ".").concat(patch);
+    if (preRelease) {
+        return "".concat(mainVersion, "-").concat(preRelease);
+    }
+    return mainVersion;
+}
+function parseHyphen(range) {
+    return range.replace(parseRegex(hyphenRange), function(_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease) {
+        if (isXVersion(fromMajor)) {
+            from = "";
+        } else if (isXVersion(fromMinor)) {
+            from = ">=".concat(fromMajor, ".0.0");
+        } else if (isXVersion(fromPatch)) {
+            from = ">=".concat(fromMajor, ".").concat(fromMinor, ".0");
+        } else {
+            from = ">=".concat(from);
+        }
+        if (isXVersion(toMajor)) {
+            to = "";
+        } else if (isXVersion(toMinor)) {
+            to = "<".concat(Number(toMajor) + 1, ".0.0-0");
+        } else if (isXVersion(toPatch)) {
+            to = "<".concat(toMajor, ".").concat(Number(toMinor) + 1, ".0-0");
+        } else if (toPreRelease) {
+            to = "<=".concat(toMajor, ".").concat(toMinor, ".").concat(toPatch, "-").concat(toPreRelease);
+        } else {
+            to = "<=".concat(to);
+        }
+        return "".concat(from, " ").concat(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(function(rangeVersion) {
+        return rangeVersion.replace(parseRegex(caret), function(_, major, minor, patch, preRelease) {
+            if (isXVersion(major)) {
+                return "";
+            } else if (isXVersion(minor)) {
+                return ">=".concat(major, ".0.0 <").concat(Number(major) + 1, ".0.0-0");
+            } else if (isXVersion(patch)) {
+                if (major === "0") {
+                    return ">=".concat(major, ".").concat(minor, ".0 <").concat(major, ".").concat(Number(minor) + 1, ".0-0");
+                } else {
+                    return ">=".concat(major, ".").concat(minor, ".0 <").concat(Number(major) + 1, ".0.0-0");
+                }
+            } else if (preRelease) {
+                if (major === "0") {
+                    if (minor === "0") {
+                        return ">=".concat(major, ".").concat(minor, ".").concat(patch, "-").concat(preRelease, " <").concat(major, ".").concat(minor, ".").concat(Number(patch) + 1, "-0");
+                    } else {
+                        return ">=".concat(major, ".").concat(minor, ".").concat(patch, "-").concat(preRelease, " <").concat(major, ".").concat(Number(minor) + 1, ".0-0");
+                    }
+                } else {
+                    return ">=".concat(major, ".").concat(minor, ".").concat(patch, "-").concat(preRelease, " <").concat(Number(major) + 1, ".0.0-0");
+                }
+            } else {
+                if (major === "0") {
+                    if (minor === "0") {
+                        return ">=".concat(major, ".").concat(minor, ".").concat(patch, " <").concat(major, ".").concat(minor, ".").concat(Number(patch) + 1, "-0");
+                    } else {
+                        return ">=".concat(major, ".").concat(minor, ".").concat(patch, " <").concat(major, ".").concat(Number(minor) + 1, ".0-0");
+                    }
+                }
+                return ">=".concat(major, ".").concat(minor, ".").concat(patch, " <").concat(Number(major) + 1, ".0.0-0");
+            }
+        });
+    }).join(" ");
+}
+function parseTildes(range) {
+    return range.trim().split(/\s+/).map(function(rangeVersion) {
+        return rangeVersion.replace(parseRegex(tilde), function(_, major, minor, patch, preRelease) {
+            if (isXVersion(major)) {
+                return "";
+            } else if (isXVersion(minor)) {
+                return ">=".concat(major, ".0.0 <").concat(Number(major) + 1, ".0.0-0");
+            } else if (isXVersion(patch)) {
+                return ">=".concat(major, ".").concat(minor, ".0 <").concat(major, ".").concat(Number(minor) + 1, ".0-0");
+            } else if (preRelease) {
+                return ">=".concat(major, ".").concat(minor, ".").concat(patch, "-").concat(preRelease, " <").concat(major, ".").concat(Number(minor) + 1, ".0-0");
+            }
+            return ">=".concat(major, ".").concat(minor, ".").concat(patch, " <").concat(major, ".").concat(Number(minor) + 1, ".0-0");
+        });
+    }).join(" ");
+}
+function parseXRanges(range) {
+    return range.split(/\s+/).map(function(rangeVersion) {
+        return rangeVersion.trim().replace(parseRegex(xRange), function(ret, gtlt, major, minor, patch, preRelease) {
+            var isXMajor = isXVersion(major);
+            var isXMinor = isXMajor || isXVersion(minor);
+            var isXPatch = isXMinor || isXVersion(patch);
+            if (gtlt === "=" && isXPatch) {
+                gtlt = "";
+            }
+            preRelease = "";
+            if (isXMajor) {
+                if (gtlt === ">" || gtlt === "<") {
+                    // nothing is allowed
+                    return "<0.0.0-0";
+                } else {
+                    // nothing is forbidden
+                    return "*";
+                }
+            } else if (gtlt && isXPatch) {
+                // replace X with 0
+                if (isXMinor) {
+                    minor = 0;
+                }
+                patch = 0;
+                if (gtlt === ">") {
+                    // >1 => >=2.0.0
+                    // >1.2 => >=1.3.0
+                    gtlt = ">=";
+                    if (isXMinor) {
+                        major = Number(major) + 1;
+                        minor = 0;
+                        patch = 0;
+                    } else {
+                        minor = Number(minor) + 1;
+                        patch = 0;
+                    }
+                } else if (gtlt === "<=") {
+                    // <=0.7.x is actually <0.8.0, since any 0.7.x should pass
+                    // Similarly, <=7.x is actually <8.0.0, etc.
+                    gtlt = "<";
+                    if (isXMinor) {
+                        major = Number(major) + 1;
+                    } else {
+                        minor = Number(minor) + 1;
+                    }
+                }
+                if (gtlt === "<") {
+                    preRelease = "-0";
+                }
+                return "".concat(gtlt + major, ".").concat(minor, ".").concat(patch).concat(preRelease);
+            } else if (isXMinor) {
+                return ">=".concat(major, ".0.0").concat(preRelease, " <").concat(Number(major) + 1, ".0.0-0");
+            } else if (isXPatch) {
+                return ">=".concat(major, ".").concat(minor, ".0").concat(preRelease, " <").concat(major, ".").concat(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) {
+    var rangePreRelease = rangeAtom.preRelease;
+    var versionPreRelease = versionAtom.preRelease;
+    if (rangePreRelease === undefined && Boolean(versionPreRelease)) {
+        return 1;
+    }
+    if (Boolean(rangePreRelease) && versionPreRelease === undefined) {
+        return -1;
+    }
+    if (rangePreRelease === undefined && versionPreRelease === undefined) {
+        return 0;
+    }
+    for(var i = 0, n = rangePreRelease.length; i <= n; i++){
+        var rangeElement = rangePreRelease[i];
+        var versionElement = versionPreRelease[i];
+        if (rangeElement === versionElement) {
+            continue;
+        }
+        if (rangeElement === undefined && versionElement === undefined) {
+            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 undefined:
+            {
+                // mean * or x -> all versions
+                return true;
+            }
+        default:
+            return false;
+    }
+}
+// fork from https://github.com/originjs/vite-plugin-federation/blob/v1.1.12/packages/lib/src/utils/semver/index.ts
+function parseComparatorString(range) {
+    return pipe(// ^ --> * (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, // ~, ~> --> * (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(// `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    parseHyphen, // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+    parseComparatorTrim, // `~ 1.2.3` => `~1.2.3`
+    parseTildeTrim, // `^ 1.2.3` => `^1.2.3`
+    parseCaretTrim)(range.trim()).split(/\s+/).join(" ");
+}
+function satisfy(version, range) {
+    if (!version) {
+        return false;
+    }
+    var parsedRange = parseRange(range);
+    var parsedComparator = parsedRange.split(" ").map(function(rangeVersion) {
+        return parseComparatorString(rangeVersion);
+    }).join(" ");
+    var comparators = parsedComparator.split(/\s+/).map(function(comparator) {
+        return parseGTE0(comparator);
+    });
+    var extractedVersion = extractComparator(version);
+    if (!extractedVersion) {
+        return false;
+    }
+    var _extractedVersion = _sliced_to_array(extractedVersion, 7), versionOperator = _extractedVersion[1], versionMajor = _extractedVersion[3], versionMinor = _extractedVersion[4], versionPatch = _extractedVersion[5], versionPreRelease = _extractedVersion[6];
+    var versionAtom = {
+        operator: versionOperator,
+        version: combineVersion(versionMajor, versionMinor, versionPatch, versionPreRelease),
+        major: versionMajor,
+        minor: versionMinor,
+        patch: versionPatch,
+        preRelease: versionPreRelease == null ? void 0 : versionPreRelease.split(".")
+    };
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = comparators[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var comparator = _step.value;
+            var extractedComparator = extractComparator(comparator);
+            if (!extractedComparator) {
+                return false;
+            }
+            var _extractedComparator = _sliced_to_array(extractedComparator, 7), rangeOperator = _extractedComparator[1], rangeMajor = _extractedComparator[3], rangeMinor = _extractedComparator[4], rangePatch = _extractedComparator[5], rangePreRelease = _extractedComparator[6];
+            var 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; // early return
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return true;
+}
+function formatShare(shareArgs, from) {
+    var get;
+    if ("get" in shareArgs) {
+        // eslint-disable-next-line prefer-destructuring
+        get = shareArgs.get;
+    } else {
+        // @ts-ignore ignore
+        get = function() {
+            return Promise.resolve(shareArgs.lib);
+        };
+    }
+    return _extends({
+        deps: [],
+        useIn: [],
+        from: from,
+        shareConfig: {
+            requiredVersion: "^".concat(shareArgs.version),
+            singleton: false,
+            eager: false
+        },
+        loading: null
+    }, shareArgs, {
+        get: get,
+        scope: Array.isArray(shareArgs.scope) ? shareArgs.scope : [
+            "default"
+        ],
+        strategy: shareArgs.strategy || "version-first"
+    });
+}
+function formatShareConfigs(shareArgs, from) {
+    if (!shareArgs) {
+        return {};
+    }
+    return Object.keys(shareArgs).reduce(function(res, pkgName) {
+        res[pkgName] = formatShare(shareArgs[pkgName], from);
+        return res;
+    }, {});
+}
+function versionLt(a, b) {
+    if (satisfy(a, "<=".concat(b))) {
+        return true;
+    } else {
+        return false;
+    }
+}
+var findVersion = function(scope, pkgName, cb) {
+    var globalShares = Global.__FEDERATION__.__SHARE__;
+    var versions = globalShares[scope][pkgName];
+    var callback = cb || function(prev, cur) {
+        return versionLt(prev, cur);
+    };
+    return Object.keys(versions).reduce(function(prev, cur) {
+        if (!prev) {
+            return cur;
+        }
+        if (callback(prev, cur)) {
+            return cur;
+        }
+        return prev;
+    }, 0);
+};
+function findSingletonVersionOrderByVersion(scope, pkgName) {
+    var globalShares = Global.__FEDERATION__.__SHARE__;
+    var versions = globalShares[scope][pkgName];
+    var callback = function callback(prev, cur) {
+        return !versions[prev].loaded && versionLt(prev, cur);
+    };
+    return findVersion(scope, pkgName, callback);
+}
+function findSingletonVersionOrderByLoaded(scope, pkgName) {
+    var globalShares = Global.__FEDERATION__.__SHARE__;
+    var versions = globalShares[scope][pkgName];
+    var callback = function callback(prev, cur) {
+        if (versions[cur].loaded) {
+            if (versions[prev].loaded) {
+                return Boolean(versionLt(prev, cur));
+            } else {
+                return true;
+            }
+        }
+        if (versions[prev].loaded) {
+            return false;
+        }
+        return versionLt(prev, cur);
+    };
+    return findVersion(scope, pkgName, callback);
+}
+// Information about sharing
+// TODO: Add strictVersion for consistency with mf.
+function getGlobalShare(pkgName, shareInfo) {
+    var globalShares = Global.__FEDERATION__.__SHARE__;
+    var shareConfig = shareInfo.shareConfig, _shareInfo_scope = shareInfo.scope, scope = _shareInfo_scope === void 0 ? DEFAULT_SCOPE : _shareInfo_scope, strategy = shareInfo.strategy;
+    var scopes = Array.isArray(scope) ? scope : [
+        scope
+    ];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = scopes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var sc = _step.value;
+            if (shareConfig && globalShares[sc] && globalShares[sc][pkgName]) {
+                var requiredVersion = shareConfig.requiredVersion;
+                // eslint-disable-next-line max-depth
+                if (shareConfig.singleton) {
+                    var singletonVersion = strategy === "loaded-first" ? findSingletonVersionOrderByLoaded(sc, pkgName) : findSingletonVersionOrderByVersion(sc, pkgName);
+                    // eslint-disable-next-line max-depth
+                    if (typeof requiredVersion === "string" && !satisfy(singletonVersion, requiredVersion)) {
+                        warn("Unsatisfied version ".concat(singletonVersion, " from ").concat(singletonVersion && globalShares[sc][pkgName][singletonVersion].from, " of shared singleton module ").concat(pkgName, " (").concat(shareInfo.from, " required ").concat(requiredVersion, ")"));
+                    }
+                    return globalShares[sc][pkgName][singletonVersion];
+                } else {
+                    var maxVersion = findSingletonVersionOrderByLoaded(sc, pkgName);
+                    // eslint-disable-next-line max-depth
+                    if (requiredVersion === false || requiredVersion === "*") {
+                        return globalShares[sc][pkgName][maxVersion];
+                    }
+                    // eslint-disable-next-line max-depth
+                    if (satisfy(maxVersion, requiredVersion)) {
+                        return globalShares[sc][pkgName][maxVersion];
+                    }
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        // eslint-disable-next-line max-depth
+                        for(var _iterator1 = Object.entries(globalShares[sc][pkgName])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var _step_value = _sliced_to_array(_step1.value, 2), versionKey = _step_value[0], versionValue = _step_value[1];
+                            // eslint-disable-next-line max-depth
+                            if (satisfy(versionKey, requiredVersion)) {
+                                return versionValue;
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+function getGlobalShareScope() {
+    return Global.__FEDERATION__.__SHARE__;
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function getResourceUrl(module, sourceUrl) {
+    if ("getPublicPath" in module) {
+        var publicPath = new Function(module.getPublicPath)();
+        return "".concat(publicPath).concat(sourceUrl);
+    } else if ("publicPath" in module) {
+        return "".concat(module.publicPath).concat(sourceUrl);
+    } else {
+        console.warn("Cannot get resource URL. If in debug mode, please ignore.", module, sourceUrl);
+        return "";
+    }
+}
+// id: pkgName(@federation/app1) + expose(button) = @federation/app1/button
+// id: alias(app1) + expose(button) = app1/button
+// id: alias(app1/utils) + expose(loadash/sort) = app1/utils/loadash/sort
+function matchRemoteWithNameAndExpose(remotes, id) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = remotes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var remote = _step.value;
+            // match pkgName
+            var matchNameSuccess = id.startsWith(remote.name);
+            var expose = id.replace(remote.name, "");
+            if (matchNameSuccess) {
+                if (expose.startsWith("/")) {
+                    var pkgNameOrAlias = remote.name;
+                    expose = ".".concat(expose);
+                    return {
+                        pkgNameOrAlias: pkgNameOrAlias,
+                        expose: expose,
+                        remote: remote
+                    };
+                } else if (expose === "") {
+                    return {
+                        pkgNameOrAlias: remote.name,
+                        expose: ".",
+                        remote: remote
+                    };
+                }
+            }
+            // match alias
+            var matchAliasSuccess = remote.alias && id.startsWith(remote.alias);
+            var exposeWithAlias = remote.alias && id.replace(remote.alias, "");
+            if (remote.alias && matchAliasSuccess) {
+                if (exposeWithAlias && exposeWithAlias.startsWith("/")) {
+                    var pkgNameOrAlias1 = remote.alias;
+                    exposeWithAlias = ".".concat(exposeWithAlias);
+                    return {
+                        pkgNameOrAlias: pkgNameOrAlias1,
+                        expose: exposeWithAlias,
+                        remote: remote
+                    };
+                } else if (exposeWithAlias === "") {
+                    return {
+                        pkgNameOrAlias: remote.alias,
+                        expose: ".",
+                        remote: remote
+                    };
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return;
+}
+function matchRemote(remotes, nameOrAlias) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = remotes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var remote = _step.value;
+            var matchNameSuccess = nameOrAlias === remote.name;
+            if (matchNameSuccess) {
+                return remote;
+            }
+            var matchAliasSuccess = remote.alias && nameOrAlias === remote.alias;
+            if (matchAliasSuccess) {
+                return remote;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return;
+}
+function createScript(url, cb, attrs, createScriptHook) {
+    // get the existing script element by src
+    var script = null;
+    var needAttach = true;
+    var scripts = document.getElementsByTagName("script");
+    for(var i = 0; i < scripts.length; i++){
+        var s = scripts[i];
+        var scriptSrc = s.getAttribute("src");
+        if (scriptSrc && isStaticResourcesEqual(scriptSrc, url)) {
+            script = s;
+            needAttach = false;
+            break;
+        }
+    }
+    if (!script) {
+        script = document.createElement("script");
+        script.type = "text/javascript";
+        script.src = url;
+        if (createScriptHook) {
+            var createScriptRes = createScriptHook(url);
+            if (_instanceof(createScriptRes, HTMLScriptElement)) {
+                script = createScriptRes;
+            }
+        }
+    }
+    if (attrs) {
+        Object.keys(attrs).forEach(function(name1) {
+            if (script) {
+                if (name1 === "async" || name1 === "defer") {
+                    script[name1] = attrs[name1];
+                } else {
+                    script.setAttribute(name1, attrs[name1]);
+                }
+            }
+        });
+    }
+    var onScriptComplete = function(prev, event) {
+        // avoid memory leaks in IE.
+        if (script) {
+            script.onerror = null;
+            script.onload = null;
+            safeWrapper(function() {
+                (script == null ? void 0 : script.parentNode) && script.parentNode.removeChild(script);
+            });
+            if (prev) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                var res = prev(event);
+                cb();
+                return res;
+            }
+        }
+        cb();
+    };
+    script.onerror = onScriptComplete.bind(null, script.onerror);
+    script.onload = onScriptComplete.bind(null, script.onload);
+    return {
+        script: script,
+        needAttach: needAttach
+    };
+}
+function loadScript(url, info) {
+    var attrs = info.attrs, createScriptHook = info.createScriptHook;
+    return new Promise(function(resolve, _reject) {
+        var _createScript = createScript(url, resolve, attrs, createScriptHook), script = _createScript.script, needAttach = _createScript.needAttach;
+        needAttach && document.getElementsByTagName("head")[0].appendChild(script);
+    });
+}
+function registerPlugins(plugins, hookInstances) {
+    var globalPlugins = getGlobalHostPlugins();
+    // Register global plugins
+    if (globalPlugins.length > 0) {
+        globalPlugins.forEach(function(plugin) {
+            if (plugins == null ? void 0 : plugins.find(function(item) {
+                return item.name !== plugin.name;
+            })) {
+                plugins.push(plugin);
+            }
+        });
+    }
+    if (plugins && plugins.length > 0) {
+        plugins.forEach(function(plugin) {
+            hookInstances.forEach(function(hookInstance) {
+                hookInstance.usePlugin(plugin);
+            });
+        });
+    }
+}
+function _instanceof1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return _instanceof(left, right);
+    }
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var MANIFEST_EXT = ".json";
+var BROWSER_LOG_KEY = "''";
+var BROWSER_LOG_VALUE = "1";
+var NameTransformSymbol = {
+    AT: "@",
+    HYPHEN: "-",
+    SLASH: "/"
+};
+var _obj;
+var NameTransformMap = (_obj = {}, _define_property$2(_obj, NameTransformSymbol.AT, "scope_"), _define_property$2(_obj, NameTransformSymbol.HYPHEN, "_"), _define_property$2(_obj, NameTransformSymbol.SLASH, "__"), _obj);
+var _obj1;
+_obj1 = {}, _define_property$2(_obj1, NameTransformMap[NameTransformSymbol.AT], NameTransformSymbol.AT), _define_property$2(_obj1, NameTransformMap[NameTransformSymbol.HYPHEN], NameTransformSymbol.HYPHEN), _define_property$2(_obj1, NameTransformMap[NameTransformSymbol.SLASH], NameTransformSymbol.SLASH);
+var SEPARATOR = ":";
+function isBrowserEnv() {
+    return typeof window !== "undefined";
+}
+function isDebugMode() {
+    if (typeof process !== "undefined" && process.env && process.env["''"]) {
+        return Boolean(process.env["''"]);
+    }
+    return Boolean("");
+}
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _class_call_check1(instance, Constructor) {
+    if (!_instanceof1(instance, Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties1(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array1(arr) {
+    return _array_without_holes1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function safeToString(info) {
+    try {
+        return JSON.stringify(info, null, 2);
+    } catch (e) {
+        return "";
+    }
+}
+var DEBUG_LOG = "[ FEDERATION DEBUG ]";
+var Logger = /*#__PURE__*/ function() {
+    function Logger(identifier) {
+        _class_call_check1(this, Logger);
+        _define_property$1(this, "enable", false);
+        _define_property$1(this, "identifier", void 0);
+        this.identifier = identifier || DEBUG_LOG;
+        if (isBrowserEnv() && localStorage.getItem(BROWSER_LOG_KEY) === BROWSER_LOG_VALUE) {
+            this.enable = true;
+        } else if (isDebugMode()) {
+            this.enable = true;
+        }
+    }
+    _create_class1(Logger, [
+        {
+            key: "info",
+            value: function info(msg, info) {
+                if (this.enable) {
+                    var argsToString = safeToString(info) || "";
+                    if (isBrowserEnv()) {
+                        console.info("%c ".concat(this.identifier, ": ").concat(msg, " ").concat(argsToString), "color:#3300CC");
+                    } else {
+                        console.info("\x1b[34m%s", "".concat(this.identifier, ": ").concat(msg, " ").concat(argsToString ? "\n".concat(argsToString) : ""));
+                    }
+                }
+            }
+        },
+        {
+            key: "logOriginalInfo",
+            value: function logOriginalInfo() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                if (this.enable) {
+                    if (isBrowserEnv()) {
+                        var _console;
+                        console.info("%c ".concat(this.identifier, ": OriginalInfo"), "color:#3300CC");
+                        (_console = console).log.apply(_console, _to_consumable_array1(args));
+                    } else {
+                        var _console1;
+                        console.info("%c ".concat(this.identifier, ": OriginalInfo"), "color:#3300CC");
+                        (_console1 = console).log.apply(_console1, _to_consumable_array1(args));
+                    }
+                }
+            }
+        }
+    ]);
+    return Logger;
+}();
+new Logger();
+var composeKeyWithSeparator = function composeKeyWithSeparator() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    if (!args.length) {
+        return "";
+    }
+    return args.reduce(function(sum, cur) {
+        if (!cur) {
+            return sum;
+        }
+        if (!sum) {
+            return cur;
+        }
+        return "".concat(sum).concat(SEPARATOR).concat(cur);
+    }, "");
+};
+function _define_property1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+var simpleJoinRemoteEntry = function simpleJoinRemoteEntry(rPath, rName) {
+    if (!rPath) {
+        return rName;
+    }
+    var transformPath = function transformPath(str) {
+        if (str === ".") {
+            return "";
+        }
+        if (str.startsWith("./")) {
+            return str.replace("./", "");
+        }
+        if (str.startsWith("/")) {
+            var strWithoutSlash = str.slice(1);
+            if (strWithoutSlash.endsWith("/")) {
+                return strWithoutSlash.slice(0, -1);
+            }
+            return strWithoutSlash;
+        }
+        return str;
+    };
+    var transformedPath = transformPath(rPath);
+    if (!transformedPath) {
+        return rName;
+    }
+    if (transformedPath.endsWith("/")) {
+        return "".concat(transformedPath).concat(rName);
+    }
+    return "".concat(transformedPath, "/").concat(rName);
+};
+// 优先级：overrides > remotes
+// eslint-disable-next-line max-lines-per-function
+function generateSnapshotFromManifest(manifest) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var _options_remotes = options.remotes, remotes = _options_remotes === void 0 ? {} : _options_remotes, _options_overrides = options.overrides, overrides = _options_overrides === void 0 ? {} : _options_overrides, version = options.version;
+    var remoteSnapshot;
+    var getPublicPath = function getPublicPath() {
+        if ("publicPath" in manifest.metaData) {
+            return manifest.metaData.publicPath;
+        } else {
+            return manifest.metaData.getPublicPath;
+        }
+    };
+    var overridesKeys = Object.keys(overrides);
+    var remotesInfo = {};
+    // If remotes are not passed, only the remotes in the manifest will be read
+    if (!Object.keys(remotes).length) {
+        var _manifest_remotes;
+        remotesInfo = ((_manifest_remotes = manifest.remotes) === null || _manifest_remotes === void 0 ? void 0 : _manifest_remotes.reduce(function(res, next) {
+            var matchedVersion;
+            var name1 = next.federationContainerName;
+            // overrides has hight priority
+            if (overridesKeys.includes(name1)) {
+                matchedVersion = overrides[name1];
+            } else {
+                if ("version" in next) {
+                    matchedVersion = next.version;
+                } else {
+                    matchedVersion = next.entry;
+                }
+            }
+            res[name1] = {
+                matchedVersion: matchedVersion
+            };
+            return res;
+        }, {})) || {};
+    }
+    // If remotes (deploy scenario) are specified, you need to traverse it again
+    Object.keys(remotes).forEach(function(key) {
+        return remotesInfo[key] = {
+            // overrides will override dependencies
+            matchedVersion: overridesKeys.includes(key) ? overrides[key] : remotes[key]
+        };
+    });
+    var _manifest_metaData = manifest.metaData, _manifest_metaData_remoteEntry = _manifest_metaData.remoteEntry, remoteEntryPath = _manifest_metaData_remoteEntry.path, remoteEntryName = _manifest_metaData_remoteEntry.name, remoteEntryType = _manifest_metaData_remoteEntry.type, remoteTypes = _manifest_metaData.types, buildVersion = _manifest_metaData.buildInfo.buildVersion, globalName = _manifest_metaData.globalName;
+    var exposes = manifest.exposes;
+    var basicRemoteSnapshot = {
+        version: version ? version : "",
+        buildVersion: buildVersion,
+        globalName: globalName,
+        remoteEntry: simpleJoinRemoteEntry(remoteEntryPath, remoteEntryName),
+        remoteEntryType: remoteEntryType,
+        remoteTypes: simpleJoinRemoteEntry(remoteTypes.path, remoteTypes.name),
+        remotesInfo: remotesInfo,
+        shared: manifest === null || manifest === void 0 ? void 0 : manifest.shared.map(function(item) {
+            return {
+                assets: item.assets,
+                sharedName: item.name
+            };
+        }),
+        modules: exposes === null || exposes === void 0 ? void 0 : exposes.map(function(expose) {
+            return {
+                moduleName: expose.name,
+                modulePath: expose.path,
+                assets: expose.assets
+            };
+        })
+    };
+    if ("publicPath" in manifest.metaData) {
+        remoteSnapshot = _object_spread_props(_object_spread({}, basicRemoteSnapshot), {
+            publicPath: getPublicPath()
+        });
+    } else {
+        remoteSnapshot = _object_spread_props(_object_spread({}, basicRemoteSnapshot), {
+            getPublicPath: getPublicPath()
+        });
+    }
+    return remoteSnapshot;
+}
+function isManifestProvider(moduleInfo) {
+    if ("remoteEntry" in moduleInfo && moduleInfo.remoteEntry.endsWith(MANIFEST_EXT)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+function loadEsmEntry(_) {
+    return _loadEsmEntry.apply(this, arguments);
+}
+function _loadEsmEntry() {
+    _loadEsmEntry = _async_to_generator(function(param) {
+        var entry, remoteEntryExports;
+        return _ts_generator(this, function(_state) {
+            entry = param.entry, remoteEntryExports = param.remoteEntryExports;
+            return [
+                2,
+                new Promise(function(resolve, reject) {
+                    try {
+                        if (!remoteEntryExports) {
+                            // eslint-disable-next-line no-eval
+                            new Function("resolve", 'import("'.concat(entry, '").then((res)=>{resolve(res);}, (error)=> reject(error))'))(resolve);
+                        } else {
+                            resolve(remoteEntryExports);
+                        }
+                    } catch (e) {
+                        reject(e);
+                    }
+                })
+            ];
+        });
+    });
+    return _loadEsmEntry.apply(this, arguments);
+}
+function loadEntryScript(_) {
+    return _loadEntryScript.apply(this, arguments);
+}
+function _loadEntryScript() {
+    _loadEntryScript = _async_to_generator(function(param) {
+        var name1, globalName, entry, createScriptHook, _getRemoteEntryExports, remoteEntryExports;
+        return _ts_generator(this, function(_state) {
+            name1 = param.name, globalName = param.globalName, entry = param.entry, createScriptHook = param.createScriptHook;
+            _getRemoteEntryExports = getRemoteEntryExports(name1, globalName), remoteEntryExports = _getRemoteEntryExports.entryExports;
+            if (remoteEntryExports) {
+                return [
+                    2,
+                    remoteEntryExports
+                ];
+            }
+            return [
+                2,
+                loadScript(entry, {
+                    attrs: {},
+                    createScriptHook: createScriptHook
+                }).then(function() {
+                    var _getRemoteEntryExports = getRemoteEntryExports(name1, globalName), remoteEntryKey = _getRemoteEntryExports.remoteEntryKey, entryExports = _getRemoteEntryExports.entryExports;
+                    assert(entryExports, "\n      Cannot use the ".concat(name1, "'s '").concat(entry, "' URL with ").concat(remoteEntryKey, "'s globalName to get remoteEntry exports.\n      The following reasons may be causing the problem:\n\n      1. '").concat(entry, "' is not the correct URL, or the remoteEntry resource or name is incorrect.\n\n      2. Unable to use ").concat(remoteEntryKey, " to get remoteEntry exports in the window object.\n    "));
+                    return entryExports;
+                })
+            ];
+        });
+    });
+    return _loadEntryScript.apply(this, arguments);
+}
+function getRemoteEntry(_) {
+    return _getRemoteEntry.apply(this, arguments);
+}
+function _getRemoteEntry() {
+    _getRemoteEntry = _async_to_generator(function(param) {
+        var remoteEntryExports, remoteInfo, createScriptHook, entry, name1, type, entryGlobalName, uniqueKey;
+        return _ts_generator(this, function(_state) {
+            remoteEntryExports = param.remoteEntryExports, remoteInfo = param.remoteInfo, createScriptHook = param.createScriptHook;
+            entry = remoteInfo.entry, name1 = remoteInfo.name, type = remoteInfo.type, entryGlobalName = remoteInfo.entryGlobalName;
+            uniqueKey = composeKeyWithSeparator(name1, entry);
+            if (remoteEntryExports) {
+                return [
+                    2,
+                    remoteEntryExports
+                ];
+            }
+            if (!globalLoading[uniqueKey]) {
+                if (type === "esm") {
+                    globalLoading[uniqueKey] = loadEsmEntry({
+                        entry: entry,
+                        remoteEntryExports: remoteEntryExports
+                    });
+                } else {
+                    globalLoading[uniqueKey] = loadEntryScript({
+                        name: name1,
+                        globalName: entryGlobalName,
+                        entry: entry,
+                        createScriptHook: createScriptHook
+                    });
+                }
+            }
+            return [
+                2,
+                globalLoading[uniqueKey]
+            ];
+        });
+    });
+    return _getRemoteEntry.apply(this, arguments);
+}
+function getRemoteInfo(remote) {
+    return _extends({}, remote, {
+        entry: "entry" in remote ? remote.entry : "",
+        type: remote.type || DEFAULT_REMOTE_TYPE,
+        entryGlobalName: remote.entryGlobalName || remote.name,
+        shareScope: remote.shareScope || DEFAULT_SCOPE
+    });
+}
+var Module = /*#__PURE__*/ function() {
+    function Module(param) {
+        var hostInfo = param.hostInfo, remoteInfo = param.remoteInfo, shared = param.shared, loaderHook = param.loaderHook;
+        _class_call_check(this, Module);
+        this.inited = false;
+        this.shared = {};
+        this.lib = undefined;
+        this.hostInfo = hostInfo;
+        this.remoteInfo = remoteInfo;
+        this.shared = shared;
+        this.loaderHook = loaderHook;
+    }
+    _create_class(Module, [
+        {
+            key: "getEntry",
+            value: function getEntry() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var remoteEntryExports;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (_this.remoteEntryExports) {
+                                    return [
+                                        2,
+                                        _this.remoteEntryExports
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    getRemoteEntry({
+                                        remoteInfo: _this.remoteInfo,
+                                        remoteEntryExports: _this.remoteEntryExports,
+                                        createScriptHook: function(url) {
+                                            var res = _this.loaderHook.lifecycle.createScript.emit({
+                                                url: url
+                                            });
+                                            if (_instanceof(res, HTMLScriptElement)) {
+                                                return res;
+                                            }
+                                            return;
+                                        }
+                                    })
+                                ];
+                            case 1:
+                                remoteEntryExports = _state.sent();
+                                assert(remoteEntryExports, "remoteEntryExports is undefined \n ".concat(safeToString$1(_this.remoteInfo)));
+                                _this.remoteEntryExports = remoteEntryExports;
+                                return [
+                                    2,
+                                    _this.remoteEntryExports
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "get",
+            value: // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+            function get(expose, options) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _ref, _ref_loadFactory, loadFactory, remoteEntryExports, globalShareScope, remoteShareScope, shareScope, remoteEntryInitOptions, federationInstance, moduleFactory, exposeContent;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _ref = options || {
+                                    loadFactory: true
+                                }, _ref_loadFactory = _ref.loadFactory, loadFactory = _ref_loadFactory === void 0 ? true : _ref_loadFactory;
+                                return [
+                                    4,
+                                    _this.getEntry()
+                                ];
+                            case 1:
+                                remoteEntryExports = _state.sent();
+                                if (!_this.inited) {
+                                    globalShareScope = Global.__FEDERATION__.__SHARE__;
+                                    remoteShareScope = _this.remoteInfo.shareScope || "default";
+                                    if (!globalShareScope[remoteShareScope]) {
+                                        globalShareScope[remoteShareScope] = {};
+                                    }
+                                    shareScope = globalShareScope[remoteShareScope];
+                                    // TODO: compat logic , it could be moved after providing startup hooks
+                                    remoteEntryInitOptions = {
+                                        version: _this.remoteInfo.version || "",
+                                        // @ts-ignore it will be passed by startup hooks
+                                        region: _this.hostInfo.region
+                                    };
+                                    remoteEntryExports.init(shareScope, [], remoteEntryInitOptions);
+                                    federationInstance = Global.__FEDERATION__.__INSTANCES__.find(function(i) {
+                                        return i.options.id === composeKeyWithSeparator(_this.remoteInfo.name, _this.remoteInfo.buildVersion);
+                                    });
+                                    if (federationInstance) {
+                                        federationInstance.initOptions(_extends({}, remoteEntryInitOptions, {
+                                            remotes: [],
+                                            name: _this.remoteInfo.name
+                                        }));
+                                    }
+                                }
+                                _this.lib = remoteEntryExports;
+                                _this.inited = true;
+                                return [
+                                    4,
+                                    remoteEntryExports.get(expose)
+                                ];
+                            case 2:
+                                moduleFactory = _state.sent();
+                                assert(moduleFactory, "".concat(getFMId(_this.remoteInfo), " remote don't export ").concat(expose, "."));
+                                if (!loadFactory) {
+                                    return [
+                                        2,
+                                        moduleFactory
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    moduleFactory()
+                                ];
+                            case 3:
+                                exposeContent = _state.sent();
+                                return [
+                                    2,
+                                    exposeContent
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return Module;
+}();
+var SyncHook = /*#__PURE__*/ function() {
+    function SyncHook(type) {
+        _class_call_check(this, SyncHook);
+        this.type = "";
+        this.listeners = new Set();
+        if (type) {
+            this.type = type;
+        }
+    }
+    _create_class(SyncHook, [
+        {
+            key: "on",
+            value: function on(fn) {
+                if (typeof fn === "function") {
+                    this.listeners.add(fn);
+                }
+            }
+        },
+        {
+            key: "once",
+            value: function once(fn) {
+                // eslint-disable-next-line @typescript-eslint/no-this-alias
+                var self = this;
+                this.on(function wrapper() {
+                    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = arguments[_key];
+                    }
+                    self.remove(wrapper);
+                    // eslint-disable-next-line prefer-spread
+                    return fn.apply(null, args);
+                });
+            }
+        },
+        {
+            key: "emit",
+            value: function emit() {
+                for(var _len = arguments.length, data = new Array(_len), _key = 0; _key < _len; _key++){
+                    data[_key] = arguments[_key];
+                }
+                var result;
+                if (this.listeners.size > 0) {
+                    // eslint-disable-next-line prefer-spread
+                    this.listeners.forEach(function(fn) {
+                        result = fn.apply(void 0, _to_consumable_array(data));
+                    });
+                }
+                return result;
+            }
+        },
+        {
+            key: "remove",
+            value: function remove(fn) {
+                this.listeners.delete(fn);
+            }
+        },
+        {
+            key: "removeAll",
+            value: function removeAll() {
+                this.listeners.clear();
+            }
+        }
+    ]);
+    return SyncHook;
+}();
+var AsyncHook = /*#__PURE__*/ function(SyncHook) {
+    _inherits(AsyncHook, SyncHook);
+    var _super = _create_super(AsyncHook);
+    function AsyncHook() {
+        _class_call_check(this, AsyncHook);
+        return _super.apply(this, arguments);
+    }
+    _create_class(AsyncHook, [
+        {
+            key: "emit",
+            value: function emit() {
+                for(var _len = arguments.length, data = new Array(_len), _key = 0; _key < _len; _key++){
+                    data[_key] = arguments[_key];
+                }
+                var result;
+                var ls = Array.from(this.listeners);
+                if (ls.length > 0) {
+                    var i = 0;
+                    var call = function(prev) {
+                        if (prev === false) {
+                            return false; // Abort process
+                        } else if (i < ls.length) {
+                            return Promise.resolve(ls[i++].apply(null, data)).then(call);
+                        } else {
+                            return prev;
+                        }
+                    };
+                    result = call();
+                }
+                return Promise.resolve(result);
+            }
+        }
+    ]);
+    return AsyncHook;
+}(SyncHook);
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function checkReturnData(originData, returnData) {
+    if (!isObject(returnData)) {
+        return false;
+    }
+    if (originData !== returnData) {
+        // eslint-disable-next-line no-restricted-syntax
+        for(var key in originData){
+            if (!(key in returnData)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+var SyncWaterfallHook = /*#__PURE__*/ function(SyncHook) {
+    _inherits(SyncWaterfallHook, SyncHook);
+    var _super = _create_super(SyncWaterfallHook);
+    function SyncWaterfallHook(type) {
+        _class_call_check(this, SyncWaterfallHook);
+        var _this;
+        _this = _super.call(this);
+        _this.onerror = error;
+        _this.type = type;
+        return _this;
+    }
+    _create_class(SyncWaterfallHook, [
+        {
+            key: "emit",
+            value: function emit(data) {
+                if (!isObject(data)) {
+                    error('"'.concat(this.type, '" hook response data must be an object.'));
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this.listeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var fn = _step.value;
+                        try {
+                            var tempData = fn(data);
+                            if (checkReturnData(data, tempData)) {
+                                data = tempData;
+                            } else {
+                                this.onerror('The "'.concat(this.type, '" type has a plugin return value error.'));
+                                break;
+                            }
+                        } catch (e) {
+                            warn(e);
+                            this.onerror(e);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return data;
+            }
+        }
+    ]);
+    return SyncWaterfallHook;
+}(SyncHook);
+var AsyncWaterfallHook = /*#__PURE__*/ function(SyncHook) {
+    _inherits(AsyncWaterfallHook, SyncHook);
+    var _super = _create_super(AsyncWaterfallHook);
+    function AsyncWaterfallHook(type) {
+        _class_call_check(this, AsyncWaterfallHook);
+        var _this;
+        _this = _super.call(this);
+        _this.onerror = error;
+        _this.type = type;
+        return _this;
+    }
+    _create_class(AsyncWaterfallHook, [
+        {
+            key: "emit",
+            value: function emit(data) {
+                var _this = this;
+                if (!isObject(data)) {
+                    error('"'.concat(this.type, '" hook response data must be an object.'));
+                }
+                var ls = Array.from(this.listeners);
+                if (ls.length > 0) {
+                    var i = 0;
+                    var processError = function(e) {
+                        warn(e);
+                        _this.onerror(e);
+                        return data;
+                    };
+                    var call = function(prevData) {
+                        if (checkReturnData(data, prevData)) {
+                            data = prevData;
+                            if (i < ls.length) {
+                                try {
+                                    return Promise.resolve(ls[i++](data)).then(call, processError);
+                                } catch (e) {
+                                    return processError(e);
+                                }
+                            }
+                        } else {
+                            _this.onerror('The "'.concat(_this.type, '" type has a plugin return value error.'));
+                        }
+                        return data;
+                    };
+                    return Promise.resolve(call(data));
+                }
+                return Promise.resolve(data);
+            }
+        }
+    ]);
+    return AsyncWaterfallHook;
+}(SyncHook);
+var PluginSystem = /*#__PURE__*/ function() {
+    function PluginSystem(lifecycle) {
+        _class_call_check(this, PluginSystem);
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
+    _create_class(PluginSystem, [
+        {
+            key: "usePlugin",
+            value: function usePlugin(plugin) {
+                var _this = this;
+                assert(isPlainObject(plugin), "Invalid plugin configuration.");
+                // The plugin name is required and must be unique
+                var pluginName = plugin.name;
+                assert(pluginName, "Plugin must provide a name.");
+                if (!this.registerPlugins[pluginName]) {
+                    this.registerPlugins[pluginName] = plugin;
+                    Object.keys(this.lifecycle).forEach(function(key) {
+                        var pluginLife = plugin[key];
+                        if (pluginLife) {
+                            _this.lifecycle[key].on(pluginLife);
+                        }
+                    });
+                }
+            }
+        },
+        {
+            key: "removePlugin",
+            value: function removePlugin(pluginName) {
+                var _this = this;
+                assert(pluginName, "Must provide a name.");
+                var plugin = this.registerPlugins[pluginName];
+                assert(plugin, 'plugin "'.concat(pluginName, '" is not registered.'));
+                Object.keys(plugin).forEach(function(key) {
+                    if (key !== "name") {
+                        _this.lifecycle[key].remove(plugin[key]);
+                    }
+                });
+            }
+        },
+        {
+            // eslint-disable-next-line @typescript-eslint/no-shadow
+            key: "inherit",
+            value: function inherit(param) {
+                var lifecycle = param.lifecycle, registerPlugins = param.registerPlugins;
+                var _this = this;
+                Object.keys(lifecycle).forEach(function(hookName) {
+                    assert(!_this.lifecycle[hookName], '"'.concat(hookName, '" hook has conflict and cannot be inherited.'));
+                    _this.lifecycle[hookName] = lifecycle[hookName];
+                });
+                Object.keys(registerPlugins).forEach(function(pluginName) {
+                    assert(!_this.registerPlugins[pluginName], '"'.concat(pluginName, '" plugin has conflict and cannot be inherited.'));
+                    _this.usePlugin(registerPlugins[pluginName]);
+                });
+            }
+        }
+    ]);
+    return PluginSystem;
+}();
+function defaultPreloadArgs(preloadConfig) {
+    return _extends({
+        resourceCategory: "sync",
+        share: true,
+        depsRemote: true
+    }, preloadConfig);
+}
+function formatPreloadArgs(remotes, preloadArgs) {
+    // let preloadOps: PreloadOptions;
+    return preloadArgs.map(function(args) {
+        var remoteInfo = matchRemote(remotes, args.nameOrAlias);
+        assert(remoteInfo, "can't preload ".concat(args.nameOrAlias, "，it is no't include in ").concat(!remoteInfo && safeToString$1({
+            remoteInfo: remoteInfo,
+            remotes: remotes
+        }), " "));
+        return {
+            remote: remoteInfo,
+            preloadConfig: defaultPreloadArgs(args)
+        };
+    });
+}
+function normalizePreloadExposes(exposes) {
+    if (!exposes) {
+        return [];
+    }
+    return exposes.map(function(expose) {
+        if (expose === ".") {
+            return expose;
+        }
+        if (expose.startsWith("./")) {
+            return expose.replace("./", "");
+        }
+        return expose;
+    });
+}
+function preloadAssets(remoteInfo, host, assets) {
+    var cssAssets = assets.cssAssets, jsAssetsWithoutEntry = assets.jsAssetsWithoutEntry, entryAssets = assets.entryAssets;
+    if (host.options.inBrowser) {
+        entryAssets.forEach(function(asset) {
+            var moduleInfo = asset.moduleInfo;
+            var module = host.moduleCache.get(remoteInfo.name);
+            if (module) {
+                getRemoteEntry({
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: module.remoteEntryExports,
+                    createScriptHook: function(url) {
+                        var res = host.loaderHook.lifecycle.createScript.emit({
+                            url: url
+                        });
+                        if (_instanceof(res, HTMLScriptElement)) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+            } else {
+                getRemoteEntry({
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: undefined,
+                    createScriptHook: function(url) {
+                        var res = host.loaderHook.lifecycle.createScript.emit({
+                            url: url
+                        });
+                        if (_instanceof(res, HTMLScriptElement)) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+            }
+        });
+        var fragment = document.createDocumentFragment();
+        cssAssets.forEach(function(cssUrl) {
+            var cssEl = document.createElement("link");
+            cssEl.setAttribute("rel", "preload");
+            cssEl.setAttribute("href", cssUrl);
+            cssEl.setAttribute("as", "style");
+            cssEl.setAttribute("crossorigin", "anonymous");
+            fragment.appendChild(cssEl);
+        });
+        document.head.appendChild(fragment);
+        jsAssetsWithoutEntry.forEach(function(jsUrl) {
+            var _createScript = createScript(jsUrl, function() {
+            // noop
+            }, {}, function(url) {
+                var res = host.loaderHook.lifecycle.createScript.emit({
+                    url: url
+                });
+                if (_instanceof(res, HTMLScriptElement)) {
+                    return res;
+                }
+                return;
+            }), scriptEl = _createScript.script;
+            document.head.appendChild(scriptEl);
+        });
+    }
+}
+function assignRemoteInfo(remoteInfo, remoteSnapshot) {
+    if (!("remoteEntry" in remoteSnapshot) || !remoteSnapshot.remoteEntry) {
+        error("The remoteEntry attribute of ".concat(name, " cannot be undefined."));
+    }
+    var remoteEntry = remoteSnapshot.remoteEntry;
+    var entryUrl = getResourceUrl(remoteSnapshot, remoteEntry);
+    remoteInfo.type = remoteSnapshot.remoteEntryType;
+    remoteInfo.entryGlobalName = remoteSnapshot.globalName;
+    remoteInfo.entry = entryUrl;
+    remoteInfo.version = remoteSnapshot.version;
+    remoteInfo.buildVersion = remoteSnapshot.buildVersion;
+}
+function snapshotPlugin() {
+    return {
+        name: "snapshot-plugin",
+        loadRemoteMatch: function loadRemoteMatch(args) {
+            return _async_to_generator(function() {
+                var remote, pkgNameOrAlias, expose, origin, remoteInfo, _ref, remoteSnapshot, globalSnapshot, preloadOptions, assets;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            remote = args.remote, pkgNameOrAlias = args.pkgNameOrAlias, expose = args.expose, origin = args.origin, remoteInfo = args.remoteInfo;
+                            if (!(!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote))) return [
+                                3,
+                                3
+                            ];
+                            return [
+                                4,
+                                origin.snapshotHandler.loadRemoteSnapshotInfo(remote)
+                            ];
+                        case 1:
+                            _ref = _state.sent(), remoteSnapshot = _ref.remoteSnapshot, globalSnapshot = _ref.globalSnapshot;
+                            assignRemoteInfo(remoteInfo, remoteSnapshot);
+                            // preload assets
+                            preloadOptions = {
+                                remote: remote,
+                                preloadConfig: {
+                                    nameOrAlias: pkgNameOrAlias,
+                                    exposes: [
+                                        expose
+                                    ],
+                                    resourceCategory: "sync",
+                                    share: false,
+                                    depsRemote: false
+                                }
+                            };
+                            return [
+                                4,
+                                origin.hooks.lifecycle.generatePreloadAssets.emit({
+                                    origin: origin,
+                                    preloadOptions: preloadOptions,
+                                    remoteInfo: remoteInfo,
+                                    remote: remote,
+                                    remoteSnapshot: remoteSnapshot,
+                                    globalSnapshot: globalSnapshot
+                                })
+                            ];
+                        case 2:
+                            assets = _state.sent();
+                            if (assets) {
+                                preloadAssets(remoteInfo, origin, assets);
+                            }
+                            _state.label = 3;
+                        case 3:
+                            return [
+                                2,
+                                args
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+}
+// name
+// name:version
+function splitId(id) {
+    var splitInfo = id.split(":");
+    if (splitInfo.length === 1) {
+        return {
+            name: splitInfo[0],
+            version: undefined
+        };
+    } else if (splitInfo.length === 2) {
+        return {
+            name: splitInfo[0],
+            version: splitInfo[1]
+        };
+    } else {
+        return {
+            name: splitInfo[1],
+            version: splitInfo[2]
+        };
+    }
+}
+// Traverse all nodes through moduleInfo and traverse the entire snapshot
+function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot) {
+    var memo = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : {}, remoteSnapshot = arguments.length > 5 ? arguments[5] : void 0, getModuleInfoHook = arguments.length > 6 ? arguments[6] : void 0;
+    var id = getFMId(remoteInfo);
+    var _getInfoWithoutType = getInfoWithoutType(globalSnapshot, id, getModuleInfoHook), snapshotValue = _getInfoWithoutType.value;
+    var effectRemoteSnapshot = remoteSnapshot || snapshotValue;
+    if (effectRemoteSnapshot && !isManifestProvider(effectRemoteSnapshot)) {
+        traverse(effectRemoteSnapshot, remoteInfo, isRoot);
+        if (effectRemoteSnapshot.remotesInfo) {
+            var remoteKeys = Object.keys(effectRemoteSnapshot.remotesInfo);
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = remoteKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var key = _step.value;
+                    if (memo[key]) {
+                        continue;
+                    }
+                    memo[key] = true;
+                    var subRemoteInfo = splitId(key);
+                    var remoteValue = effectRemoteSnapshot.remotesInfo[key];
+                    traverseModuleInfo(globalSnapshot, {
+                        name: subRemoteInfo.name,
+                        version: remoteValue.matchedVersion
+                    }, traverse, false, memo, undefined, getModuleInfoHook);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+    }
+}
+// eslint-disable-next-line max-lines-per-function
+function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, remoteSnapshot) {
+    var cssAssets = [];
+    var jsAssets = [];
+    var entryAssets = [];
+    var loadedSharedJsAssets = new Set();
+    var loadedSharedCssAssets = new Set();
+    var options = origin.options;
+    var rootPreloadConfig = preloadOptions.preloadConfig;
+    var depsRemote = rootPreloadConfig.depsRemote;
+    var memo = {};
+    traverseModuleInfo(globalSnapshot, remote, function(moduleInfoSnapshot, remoteInfo, isRoot) {
+        var handlerAssets = function handlerAssets(assets) {
+            var assetsRes = assets.map(function(asset) {
+                return getResourceUrl(moduleInfoSnapshot, asset);
+            });
+            if (preloadConfig.filter) {
+                return assetsRes.filter(preloadConfig.filter);
+            }
+            return assetsRes;
+        };
+        var preloadConfig;
+        if (isRoot) {
+            preloadConfig = rootPreloadConfig;
+        } else {
+            if (Array.isArray(depsRemote)) {
+                // eslint-disable-next-line array-callback-return
+                var findPreloadConfig = depsRemote.find(function(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;
+            }
+        }
+        var remoteEntryUrl = getResourceUrl(moduleInfoSnapshot, "remoteEntry" in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntry : "");
+        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 : undefined
+                },
+                url: remoteEntryUrl
+            });
+        }
+        var moduleAssetsInfo = "modules" in moduleInfoSnapshot ? moduleInfoSnapshot.modules : [];
+        var 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(function(assets, moduleAssetInfo) {
+                if ((normalizedPreloadExposes == null ? void 0 : normalizedPreloadExposes.indexOf(moduleAssetInfo.moduleName)) !== -1) {
+                    assets.push(moduleAssetInfo);
+                }
+                return assets;
+            }, []);
+        }
+        if (moduleAssetsInfo) {
+            var assetsLength = moduleAssetsInfo.length;
+            for(var index = 0; index < assetsLength; index++){
+                var assetsInfo = moduleAssetsInfo[index];
+                // for (const assetsInfo of moduleAssetsInfo) {
+                var exposeFullPath = "".concat(remoteInfo.name, "/").concat(assetsInfo.moduleName);
+                var preloaded = getPreloaded(exposeFullPath);
+                if (preloaded) {
+                    continue;
+                }
+                if (preloadConfig.resourceCategory === "all") {
+                    var _cssAssets, _cssAssets1, _jsAssets, _jsAssets1;
+                    (_cssAssets = cssAssets).push.apply(_cssAssets, _to_consumable_array(handlerAssets(assetsInfo.assets.css.async)));
+                    (_cssAssets1 = cssAssets).push.apply(_cssAssets1, _to_consumable_array(handlerAssets(assetsInfo.assets.css.sync)));
+                    (_jsAssets = jsAssets).push.apply(_jsAssets, _to_consumable_array(handlerAssets(assetsInfo.assets.js.async)));
+                    (_jsAssets1 = jsAssets).push.apply(_jsAssets1, _to_consumable_array(handlerAssets(assetsInfo.assets.js.sync)));
+                // eslint-disable-next-line no-constant-condition
+                } else if (preloadConfig.resourceCategory = "sync") {
+                    var _cssAssets2, _jsAssets2;
+                    (_cssAssets2 = cssAssets).push.apply(_cssAssets2, _to_consumable_array(handlerAssets(assetsInfo.assets.css.sync)));
+                    (_jsAssets2 = jsAssets).push.apply(_jsAssets2, _to_consumable_array(handlerAssets(assetsInfo.assets.js.sync)));
+                }
+                setPreloaded(exposeFullPath);
+            }
+        }
+    }, true, memo, remoteSnapshot, function(target, key) {
+        var res = origin.loaderHook.lifecycle.getModuleInfo.emit({
+            target: target,
+            key: key
+        });
+        if (res && !_instanceof(res, Promise)) {
+            return res;
+        }
+        return;
+    });
+    if (remoteSnapshot.shared) {
+        remoteSnapshot.shared.forEach(function(shared) {
+            var _options_shared;
+            var shareInfo = (_options_shared = options.shared) == null ? void 0 : _options_shared[shared.sharedName];
+            // When data is downgraded, the shared configuration may be different.
+            if (!shareInfo) {
+                return;
+            }
+            var globalShare = getGlobalShare(shared.sharedName, shareInfo);
+            // If the global share does not exist, or the lib function does not exist, it means that the shared has not been loaded yet and can be preloaded.
+            if (globalShare && typeof globalShare.lib === "function") {
+                shared.assets.js.sync.forEach(function(asset) {
+                    loadedSharedJsAssets.add(asset);
+                });
+                shared.assets.css.sync.forEach(function(asset) {
+                    loadedSharedCssAssets.add(asset);
+                });
+            }
+        });
+    }
+    var needPreloadJsAssets = jsAssets.filter(function(asset) {
+        return !loadedSharedJsAssets.has(asset);
+    });
+    var needPreloadCssAssets = cssAssets.filter(function(asset) {
+        return !loadedSharedCssAssets.has(asset);
+    });
+    return {
+        cssAssets: needPreloadCssAssets,
+        jsAssetsWithoutEntry: needPreloadJsAssets,
+        entryAssets: entryAssets
+    };
+}
+var generatePreloadAssetsPlugin = function generatePreloadAssetsPlugin() {
+    return {
+        name: "generate-preload-assets-plugin",
+        generatePreloadAssets: function generatePreloadAssets1(args) {
+            return _async_to_generator(function() {
+                var origin, preloadOptions, remoteInfo, remote, globalSnapshot, remoteSnapshot, assets;
+                return _ts_generator(this, function(_state) {
+                    origin = args.origin, preloadOptions = args.preloadOptions, remoteInfo = args.remoteInfo, remote = args.remote, globalSnapshot = args.globalSnapshot, remoteSnapshot = args.remoteSnapshot;
+                    if (isRemoteInfoWithEntry(remote) && isPureRemoteEntry(remote)) {
+                        return [
+                            2,
+                            {
+                                cssAssets: [],
+                                jsAssetsWithoutEntry: [],
+                                entryAssets: [
+                                    {
+                                        name: remote.name,
+                                        url: remote.entry,
+                                        moduleInfo: {
+                                            name: remoteInfo.name,
+                                            entry: remote.entry,
+                                            type: "global",
+                                            entryGlobalName: "",
+                                            shareScope: ""
+                                        }
+                                    }
+                                ]
+                            }
+                        ];
+                    }
+                    assignRemoteInfo(remoteInfo, remoteSnapshot);
+                    assets = generatePreloadAssets(origin, preloadOptions, remoteInfo, globalSnapshot, remoteSnapshot);
+                    return [
+                        2,
+                        assets
+                    ];
+                });
+            })();
+        }
+    };
+};
+var SnapshotHandler = /*#__PURE__*/ function() {
+    function SnapshotHandler(HostInstance) {
+        _class_call_check(this, SnapshotHandler);
+        this.loadingHostSnapshot = null;
+        this.manifestCache = new Map();
+        this.hooks = new PluginSystem({
+            beforeLoadRemoteSnapshot: new AsyncHook("beforeLoadRemoteSnapshot"),
+            loadSnapshot: new AsyncWaterfallHook("loadGlobalSnapshot"),
+            loadRemoteSnapshot: new AsyncWaterfallHook("loadRemoteSnapshot")
+        });
+        this.manifestLoading = Global.__FEDERATION__.__MANIFEST_LOADING__;
+        this.HostInstance = HostInstance;
+    }
+    _create_class(SnapshotHandler, [
+        {
+            key: "loadSnapshot",
+            value: function loadSnapshot(moduleInfo) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var options, _this_getGlobalRemoteInfo, hostGlobalSnapshot, remoteSnapshot, globalSnapshot, _ref, globalRemoteSnapshot, globalSnapshotRes;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                options = _this.HostInstance.options;
+                                _this_getGlobalRemoteInfo = _this.getGlobalRemoteInfo(moduleInfo), hostGlobalSnapshot = _this_getGlobalRemoteInfo.hostGlobalSnapshot, remoteSnapshot = _this_getGlobalRemoteInfo.remoteSnapshot, globalSnapshot = _this_getGlobalRemoteInfo.globalSnapshot;
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.loadSnapshot.emit({
+                                        options: options,
+                                        moduleInfo: moduleInfo,
+                                        hostGlobalSnapshot: hostGlobalSnapshot,
+                                        remoteSnapshot: remoteSnapshot,
+                                        globalSnapshot: globalSnapshot
+                                    })
+                                ];
+                            case 1:
+                                _ref = _state.sent(), globalRemoteSnapshot = _ref.remoteSnapshot, globalSnapshotRes = _ref.globalSnapshot;
+                                return [
+                                    2,
+                                    {
+                                        remoteSnapshot: globalRemoteSnapshot,
+                                        globalSnapshot: globalSnapshotRes
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "loadRemoteSnapshotInfo",
+            value: // eslint-disable-next-line max-lines-per-function
+            function loadRemoteSnapshotInfo(moduleInfo) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var options, hostSnapshot, _this_getGlobalRemoteInfo, hostGlobalSnapshot, remoteSnapshot, globalSnapshot, _ref, globalRemoteSnapshot, globalSnapshotRes, moduleSnapshot, globalSnapshotRes1, _ref1, remoteSnapshotRes, moduleSnapshot1, globalSnapshotRes2, _ref2, remoteSnapshotRes1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                options = _this.HostInstance.options;
+                                hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
+                                    name: _this.HostInstance.options.name,
+                                    version: _this.HostInstance.options.version
+                                }, {
+                                    getModuleInfoHook: function(target, key) {
+                                        var res = _this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                                            target: target,
+                                            key: key
+                                        });
+                                        if (res && !_instanceof(res, Promise)) {
+                                            return res;
+                                        }
+                                        return;
+                                    }
+                                });
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
+                                        options: options,
+                                        moduleInfo: moduleInfo
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                // In the dynamic loadRemote scenario, incomplete remotesInfo delivery may occur. In this case, the remotesInfo in the host needs to be completed in the snapshot at runtime.
+                                // Ensure the integrity of the snapshot, and at the same time help the chrome plug-in correctly identify all producer modules, ensuring that proxyable producer modules will not be missing
+                                // In the dynamic loadRemote scenario, incomplete remotesInfo delivery may occur. In this case, the remotesInfo in the host needs to be completed in the snapshot at runtime.
+                                // Ensure the integrity of the snapshot, and at the same time help the chrome plug-in correctly identify all producer modules, ensuring that proxyable producer modules will not be missing
+                                if (hostSnapshot && "remotesInfo" in hostSnapshot && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name, function(target, key) {
+                                    var res = _this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                                        target: target,
+                                        key: key
+                                    });
+                                    if (res && !_instanceof(res, Promise)) {
+                                        return res;
+                                    }
+                                    return;
+                                }).value) {
+                                    if ("version" in moduleInfo || "entry" in moduleInfo) {
+                                        hostSnapshot.remotesInfo = _extends({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, _define_property({}, moduleInfo.name, {
+                                            matchedVersion: "version" in moduleInfo ? moduleInfo.version : moduleInfo.entry
+                                        }));
+                                    }
+                                }
+                                _this_getGlobalRemoteInfo = _this.getGlobalRemoteInfo(moduleInfo), hostGlobalSnapshot = _this_getGlobalRemoteInfo.hostGlobalSnapshot, remoteSnapshot = _this_getGlobalRemoteInfo.remoteSnapshot, globalSnapshot = _this_getGlobalRemoteInfo.globalSnapshot;
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.loadSnapshot.emit({
+                                        options: options,
+                                        moduleInfo: moduleInfo,
+                                        hostGlobalSnapshot: hostGlobalSnapshot,
+                                        remoteSnapshot: remoteSnapshot,
+                                        globalSnapshot: globalSnapshot
+                                    })
+                                ];
+                            case 2:
+                                _ref = _state.sent(), globalRemoteSnapshot = _ref.remoteSnapshot, globalSnapshotRes = _ref.globalSnapshot;
+                                if (!globalRemoteSnapshot) return [
+                                    3,
+                                    7
+                                ];
+                                if (!isManifestProvider(globalRemoteSnapshot)) return [
+                                    3,
+                                    4
+                                ];
+                                return [
+                                    4,
+                                    _this.getManifestJson(globalRemoteSnapshot.remoteEntry, moduleInfo, {})
+                                ];
+                            case 3:
+                                moduleSnapshot = _state.sent();
+                                // eslint-disable-next-line @typescript-eslint/no-shadow
+                                globalSnapshotRes1 = setGlobalSnapshotInfoByModuleInfo(_extends({}, moduleInfo), moduleSnapshot);
+                                return [
+                                    2,
+                                    {
+                                        remoteSnapshot: moduleSnapshot,
+                                        globalSnapshot: globalSnapshotRes1
+                                    }
+                                ];
+                            case 4:
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.loadRemoteSnapshot.emit({
+                                        options: _this.HostInstance.options,
+                                        moduleInfo: moduleInfo,
+                                        remoteSnapshot: globalRemoteSnapshot,
+                                        from: "global"
+                                    })
+                                ];
+                            case 5:
+                                _ref1 = _state.sent(), remoteSnapshotRes = _ref1.remoteSnapshot;
+                                return [
+                                    2,
+                                    {
+                                        remoteSnapshot: remoteSnapshotRes,
+                                        globalSnapshot: globalSnapshotRes
+                                    }
+                                ];
+                            case 6:
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 7:
+                                if (!isRemoteInfoWithEntry(moduleInfo)) return [
+                                    3,
+                                    10
+                                ];
+                                return [
+                                    4,
+                                    _this.getManifestJson(moduleInfo.entry, moduleInfo, {})
+                                ];
+                            case 8:
+                                moduleSnapshot1 = _state.sent();
+                                // eslint-disable-next-line @typescript-eslint/no-shadow
+                                globalSnapshotRes2 = setGlobalSnapshotInfoByModuleInfo(moduleInfo, moduleSnapshot1);
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.loadRemoteSnapshot.emit({
+                                        options: _this.HostInstance.options,
+                                        moduleInfo: moduleInfo,
+                                        remoteSnapshot: moduleSnapshot1,
+                                        from: "global"
+                                    })
+                                ];
+                            case 9:
+                                _ref2 = _state.sent(), remoteSnapshotRes1 = _ref2.remoteSnapshot;
+                                return [
+                                    2,
+                                    {
+                                        remoteSnapshot: remoteSnapshotRes1,
+                                        globalSnapshot: globalSnapshotRes2
+                                    }
+                                ];
+                            case 10:
+                                error("\n          Cannot get remoteSnapshot with the name: '".concat(moduleInfo.name, "', version: '").concat(moduleInfo.version, "' from __FEDERATION__.moduleInfo. The following reasons may be causing the problem:\n\n          1. The Deploy platform did not deliver the correct data. You can use __FEDERATION__.moduleInfo to check the remoteInfo.\n\n          2. The remote '").concat(moduleInfo.name, "' version '").concat(moduleInfo.version, "' is not released.\n\n          The transformed module info: ").concat(JSON.stringify(globalSnapshotRes), "\n        "));
+                                _state.label = 11;
+                            case 11:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "getGlobalRemoteInfo",
+            value: function getGlobalRemoteInfo(moduleInfo) {
+                var _this = this;
+                var hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({
+                    name: this.HostInstance.options.name,
+                    version: this.HostInstance.options.version
+                }, {
+                    getModuleInfoHook: function(target, key) {
+                        var res = _this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                            target: target,
+                            key: key
+                        });
+                        if (res && !_instanceof(res, Promise)) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+                // get remote detail info from global
+                var globalRemoteInfo = hostGlobalSnapshot && "remotesInfo" in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name, function(target, key) {
+                    var res = _this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                        target: target,
+                        key: key
+                    });
+                    if (res && !_instanceof(res, Promise)) {
+                        return res;
+                    }
+                    return;
+                }).value;
+                if (globalRemoteInfo && globalRemoteInfo.matchedVersion) {
+                    return {
+                        hostGlobalSnapshot: hostGlobalSnapshot,
+                        globalSnapshot: getGlobalSnapshot(),
+                        remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+                            name: moduleInfo.name,
+                            version: globalRemoteInfo.matchedVersion
+                        }, {
+                            getModuleInfoHook: function(target, key) {
+                                var res = _this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                                    target: target,
+                                    key: key
+                                });
+                                if (res && !_instanceof(res, Promise)) {
+                                    return res;
+                                }
+                                return;
+                            }
+                        })
+                    };
+                }
+                return {
+                    hostGlobalSnapshot: undefined,
+                    globalSnapshot: getGlobalSnapshot(),
+                    remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+                        name: moduleInfo.name,
+                        version: "version" in moduleInfo ? moduleInfo.version : undefined
+                    }, {
+                        getModuleInfoHook: function(target, key) {
+                            var res = _this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                                target: target,
+                                key: key
+                            });
+                            if (res && !_instanceof(res, Promise)) {
+                                return res;
+                            }
+                            return;
+                        }
+                    })
+                };
+            }
+        },
+        {
+            key: "getManifestJson",
+            value: function getManifestJson(manifestUrl, moduleInfo, extraOptions) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var getManifest, asyncLoadProcess;
+                    return _ts_generator(this, function(_state) {
+                        getManifest = function() {
+                            var _ref = _async_to_generator(function() {
+                                var manifestJson, res, err;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            manifestJson = _this.manifestCache.get(manifestUrl);
+                                            if (manifestJson) {
+                                                return [
+                                                    2,
+                                                    manifestJson
+                                                ];
+                                            }
+                                            _state.label = 1;
+                                        case 1:
+                                            _state.trys.push([
+                                                1,
+                                                4,
+                                                ,
+                                                5
+                                            ]);
+                                            return [
+                                                4,
+                                                fetch(manifestUrl)
+                                            ];
+                                        case 2:
+                                            res = _state.sent();
+                                            return [
+                                                4,
+                                                res.json()
+                                            ];
+                                        case 3:
+                                            manifestJson = _state.sent();
+                                            assert(manifestJson.metaData && manifestJson.exposes && manifestJson.shared, "".concat(manifestUrl, " is not federation manifest"));
+                                            _this.manifestCache.set(manifestUrl, manifestJson);
+                                            return [
+                                                2,
+                                                manifestJson
+                                            ];
+                                        case 4:
+                                            err = _state.sent();
+                                            error("Failed to get manifestJson for ".concat(moduleInfo.name, ". The manifest URL is ").concat(manifestUrl, ". Please ensure that the manifestUrl is accessible.\n          \n Error message:\n          \n ").concat(err));
+                                            return [
+                                                3,
+                                                5
+                                            ];
+                                        case 5:
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            });
+                            return function getManifest() {
+                                return _ref.apply(this, arguments);
+                            };
+                        }();
+                        asyncLoadProcess = function() {
+                            var _ref = _async_to_generator(function() {
+                                var manifestJson, remoteSnapshot, _ref, remoteSnapshotRes;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                getManifest()
+                                            ];
+                                        case 1:
+                                            manifestJson = _state.sent();
+                                            remoteSnapshot = generateSnapshotFromManifest(manifestJson, {
+                                                version: manifestUrl
+                                            });
+                                            return [
+                                                4,
+                                                _this.hooks.lifecycle.loadRemoteSnapshot.emit({
+                                                    options: _this.HostInstance.options,
+                                                    moduleInfo: moduleInfo,
+                                                    manifestJson: manifestJson,
+                                                    remoteSnapshot: remoteSnapshot,
+                                                    manifestUrl: manifestUrl,
+                                                    from: "manifest"
+                                                })
+                                            ];
+                                        case 2:
+                                            _ref = _state.sent(), remoteSnapshotRes = _ref.remoteSnapshot;
+                                            return [
+                                                2,
+                                                remoteSnapshotRes
+                                            ];
+                                    }
+                                });
+                            });
+                            return function asyncLoadProcess() {
+                                return _ref.apply(this, arguments);
+                            };
+                        }();
+                        if (!_this.manifestLoading[manifestUrl]) {
+                            _this.manifestLoading[manifestUrl] = asyncLoadProcess().then(function(res) {
+                                return res;
+                            });
+                        }
+                        return [
+                            2,
+                            _this.manifestLoading[manifestUrl]
+                        ];
+                    });
+                })();
+            }
+        }
+    ]);
+    return SnapshotHandler;
+}();
+var FederationHost = /*#__PURE__*/ function() {
+    function FederationHost(userOptions) {
+        _class_call_check(this, FederationHost);
+        this.hooks = new PluginSystem({
+            beforeInit: new SyncWaterfallHook("beforeInit"),
+            init: new SyncHook(),
+            beforeLoadRemote: new AsyncWaterfallHook("beforeLoadRemote"),
+            loadRemoteMatch: new AsyncWaterfallHook("loadRemoteMatch"),
+            loadRemote: new AsyncHook("loadRemote"),
+            errorLoadRemote: new AsyncHook("errorLoadRemote"),
+            beforeLoadShare: new AsyncWaterfallHook("beforeLoadShare"),
+            loadShare: new AsyncHook(),
+            beforePreloadRemote: new AsyncHook(),
+            generatePreloadAssets: new AsyncHook("generatePreloadAssets"),
+            afterPreloadRemote: new AsyncHook()
+        });
+        this.version = "1.0.0-canary.1";
+        this.moduleCache = new Map();
+        this.loaderHook = new PluginSystem({
+            // FIXME: may not be suitable
+            getModuleInfo: new SyncHook(),
+            createScript: new SyncHook()
+        });
+        this.loadingShare = {};
+        // TODO: check options detail type
+        // set options default value
+        var defaultOptions = {
+            id: getBuilderId(),
+            name: userOptions.name,
+            plugins: [
+                snapshotPlugin(),
+                generatePreloadAssetsPlugin()
+            ],
+            remotes: [],
+            shared: {},
+            inBrowser: isBrowserEnv$1()
+        };
+        this.name = userOptions.name;
+        this.options = defaultOptions;
+        this.snapshotHandler = new SnapshotHandler(this);
+        this.registerPlugins(_to_consumable_array(defaultOptions.plugins).concat(_to_consumable_array(userOptions.plugins || [])));
+        this.options = this.formatOptions(defaultOptions, userOptions);
+    }
+    _create_class(FederationHost, [
+        {
+            key: "initOptions",
+            value: function initOptions(userOptions) {
+                this.registerPlugins(userOptions.plugins);
+                var options = this.formatOptions(this.options, userOptions);
+                this.options = options;
+                return options;
+            }
+        },
+        {
+            key: "loadShare",
+            value: // overrideSharedOptions(shareScope: GlobalShareScope[string]): void {}
+            function loadShare(pkgName, customShareInfo) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _this_options_shared, shareInfo, loadShareRes, shareInfoRes, globalShare, factory, asyncLoadProcess, loading, asyncLoadProcess1, loading1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // 1. Verify whether the currently loaded share already exists, and report an error if it does not exist
+                                // 2. Search globally to see if there is a matching share, and if so, use it directly
+                                // 3. If not, get it from the current share and store the obtained share globally.
+                                shareInfo = Object.assign({}, (_this_options_shared = _this.options.shared) == null ? void 0 : _this_options_shared[pkgName], customShareInfo);
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforeLoadShare.emit({
+                                        pkgName: pkgName,
+                                        shareInfo: shareInfo,
+                                        shared: _this.options.shared,
+                                        origin: _this
+                                    })
+                                ];
+                            case 1:
+                                loadShareRes = _state.sent();
+                                shareInfoRes = loadShareRes.shareInfo;
+                                assert(shareInfoRes, "cannot find ".concat(pkgName, " Share in the ").concat(_this.options.name, ". Perhaps you have not injected the ").concat(pkgName, " Share parameters"));
+                                // get from cache
+                                globalShare = getGlobalShare(pkgName, shareInfoRes);
+                                if (!(globalShare && globalShare.lib)) return [
+                                    3,
+                                    2
+                                ];
+                                addUniqueItem(globalShare.useIn, _this.options.name);
+                                return [
+                                    2,
+                                    globalShare.lib
+                                ];
+                            case 2:
+                                if (!(globalShare && globalShare.loading)) return [
+                                    3,
+                                    4
+                                ];
+                                return [
+                                    4,
+                                    globalShare.loading
+                                ];
+                            case 3:
+                                factory = _state.sent();
+                                addUniqueItem(globalShare.useIn, _this.options.name);
+                                return [
+                                    2,
+                                    factory
+                                ];
+                            case 4:
+                                if (globalShare) {
+                                    asyncLoadProcess = function() {
+                                        var _ref = _async_to_generator(function() {
+                                            var factory, gShared;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        return [
+                                                            4,
+                                                            globalShare.get()
+                                                        ];
+                                                    case 1:
+                                                        factory = _state.sent();
+                                                        shareInfoRes.lib = factory;
+                                                        addUniqueItem(shareInfoRes.useIn, _this.options.name);
+                                                        gShared = getGlobalShare(pkgName, shareInfoRes);
+                                                        if (gShared) {
+                                                            gShared.lib = factory;
+                                                        }
+                                                        return [
+                                                            2,
+                                                            factory
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function asyncLoadProcess() {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }();
+                                    loading = asyncLoadProcess();
+                                    _this.setShared({
+                                        pkgName: pkgName,
+                                        loaded: true,
+                                        shared: shareInfoRes,
+                                        from: _this.options.name,
+                                        lib: null,
+                                        loading: loading
+                                    });
+                                    return [
+                                        2,
+                                        loading
+                                    ];
+                                } else {
+                                    if (customShareInfo) {
+                                        return [
+                                            2,
+                                            false
+                                        ];
+                                    }
+                                    asyncLoadProcess1 = function() {
+                                        var _ref = _async_to_generator(function() {
+                                            var factory, gShared;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        return [
+                                                            4,
+                                                            shareInfoRes.get()
+                                                        ];
+                                                    case 1:
+                                                        factory = _state.sent();
+                                                        shareInfoRes.lib = factory;
+                                                        addUniqueItem(shareInfoRes.useIn, _this.options.name);
+                                                        gShared = getGlobalShare(pkgName, shareInfoRes);
+                                                        if (gShared) {
+                                                            gShared.lib = factory;
+                                                        }
+                                                        return [
+                                                            2,
+                                                            factory
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function asyncLoadProcess1() {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }();
+                                    loading1 = asyncLoadProcess1();
+                                    _this.setShared({
+                                        pkgName: pkgName,
+                                        loaded: true,
+                                        shared: shareInfoRes,
+                                        from: _this.options.name,
+                                        lib: null,
+                                        loading: loading1
+                                    });
+                                    return [
+                                        2,
+                                        loading1
+                                    ];
+                                }
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            // There will be a lib function only 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 reuse
+            // 2. If lib exists in local shared, use it directly
+            // 3. If the local get returns something other than Promise, then use it directly
+            key: "loadShareSync",
+            value: function loadShareSync(pkgName) {
+                var _this_options_shared;
+                var shareInfo = (_this_options_shared = this.options.shared) == null ? void 0 : _this_options_shared[pkgName];
+                var globalShare = getGlobalShare(pkgName, shareInfo);
+                if (globalShare && typeof globalShare.lib === "function") {
+                    addUniqueItem(globalShare.useIn, this.options.name);
+                    if (!globalShare.loaded) {
+                        globalShare.loaded = true;
+                        if (globalShare.from === this.options.name) {
+                            shareInfo.loaded = true;
+                        }
+                    }
+                    return globalShare.lib;
+                }
+                if (shareInfo.lib) {
+                    if (!shareInfo.loaded) {
+                        shareInfo.loaded = true;
+                    }
+                    return shareInfo.lib;
+                }
+                if (shareInfo.get) {
+                    var module = shareInfo.get();
+                    if (_instanceof(module, Promise)) {
+                        throw new Error("\n        The loadShareSync function failed to load ".concat(pkgName, ". Cannot find ").concat(pkgName, " in ").concat(this.options.name, ".\n        Failure reason: \n\n        1. Registered ").concat(pkgName, " share with the 'get' attribute, but did not use loadShare before.\n\n        2. Did not register ").concat(pkgName, " share with the 'lib' attribute.\n\n      "));
+                    }
+                    shareInfo.lib = module;
+                    this.setShared({
+                        pkgName: pkgName,
+                        loaded: true,
+                        from: this.options.name,
+                        lib: shareInfo.lib,
+                        shared: shareInfo
+                    });
+                    return shareInfo.lib;
+                }
+                throw new Error("\n        The loadShareSync function failed to load ".concat(pkgName, ". Cannot find ").concat(pkgName, " in ").concat(this.options.name, ".\n        Failure reason: \n\n        1. Registered ").concat(pkgName, " share with the 'get' attribute, but did not use loadShare before.\n\n        2. Did not register ").concat(pkgName, " share with the 'lib' attribute.\n\n      "));
+            }
+        },
+        {
+            key: "_getRemoteModuleAndOptions",
+            value: function _getRemoteModuleAndOptions(id) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var loadRemoteArgs, idRes, remoteSplitInfo, rawRemote, remoteInfo, matchInfo, remote, expose, module, moduleOptions;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforeLoadRemote.emit({
+                                        id: id,
+                                        options: _this.options,
+                                        origin: _this
+                                    })
+                                ];
+                            case 1:
+                                loadRemoteArgs = _state.sent();
+                                idRes = loadRemoteArgs.id;
+                                remoteSplitInfo = matchRemoteWithNameAndExpose(_this.options.remotes, idRes);
+                                assert(remoteSplitInfo, "\n        Cannot find ".concat(idRes, " in ").concat(_this.options.name, ". Possible cause of failure:\n\n        1. ").concat(idRes, " was not injected into ").concat(_this.options.name, "'s 'remotes' parameter.\n\n        2. Cannot find ").concat(idRes, " in ").concat(_this.options.name, "'s 'remotes' with attribute 'name' or 'alias'.\n        3. The 'beforeLoadRemote' hook was provided but did not return the correct 'remoteInfo' when loading ").concat(idRes, ".\n      "));
+                                rawRemote = remoteSplitInfo.remote;
+                                remoteInfo = getRemoteInfo(rawRemote);
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.loadRemoteMatch.emit(_extends({
+                                        id: idRes
+                                    }, remoteSplitInfo, {
+                                        options: _this.options,
+                                        origin: _this,
+                                        remoteInfo: remoteInfo
+                                    }))
+                                ];
+                            case 2:
+                                matchInfo = _state.sent();
+                                remote = matchInfo.remote, expose = matchInfo.expose;
+                                assert(remote && expose, "The 'beforeLoadRemote' hook was provided but did not return the correct 'remote' and 'expose' when loading ".concat(idRes, "."));
+                                module = _this.moduleCache.get(remote.name);
+                                moduleOptions = {
+                                    hostInfo: {
+                                        name: _this.options.name,
+                                        version: _this.options.version || "custom"
+                                    },
+                                    remoteInfo: remoteInfo,
+                                    shared: _this.options.shared || {},
+                                    plugins: _this.options.plugins,
+                                    loaderHook: _this.loaderHook
+                                };
+                                if (!module) {
+                                    module = new Module(moduleOptions);
+                                    _this.moduleCache.set(remote.name, module);
+                                }
+                                return [
+                                    2,
+                                    {
+                                        module: module,
+                                        moduleOptions: moduleOptions,
+                                        remoteMatchInfo: matchInfo
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "loadRemote",
+            value: // eslint-disable-next-line max-lines-per-function
+            // eslint-disable-next-line @typescript-eslint/member-ordering
+            function loadRemote(id, options) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _ref, _ref_loadFactory, loadFactory, _ref1, module, moduleOptions, remoteMatchInfo, pkgNameOrAlias, remote, expose, idRes, moduleOrFactory, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                _ref = options || {
+                                    loadFactory: true
+                                }, _ref_loadFactory = _ref.loadFactory, loadFactory = _ref_loadFactory === void 0 ? true : _ref_loadFactory;
+                                return [
+                                    4,
+                                    _this._getRemoteModuleAndOptions(id)
+                                ];
+                            case 1:
+                                _ref1 = _state.sent(), module = _ref1.module, moduleOptions = _ref1.moduleOptions, remoteMatchInfo = _ref1.remoteMatchInfo;
+                                pkgNameOrAlias = remoteMatchInfo.pkgNameOrAlias, remote = remoteMatchInfo.remote, expose = remoteMatchInfo.expose, idRes = remoteMatchInfo.id;
+                                return [
+                                    4,
+                                    module.get(expose, options)
+                                ];
+                            case 2:
+                                moduleOrFactory = _state.sent();
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.loadRemote.emit({
+                                        id: idRes,
+                                        pkgNameOrAlias: pkgNameOrAlias,
+                                        expose: expose,
+                                        exposeModule: loadFactory ? moduleOrFactory : undefined,
+                                        exposeModuleFactory: loadFactory ? undefined : moduleOrFactory,
+                                        remote: remote,
+                                        options: moduleOptions,
+                                        moduleInstance: module,
+                                        origin: _this
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    2,
+                                    moduleOrFactory
+                                ];
+                            case 4:
+                                error = _state.sent();
+                                _this.hooks.lifecycle.errorLoadRemote.emit({
+                                    id: id,
+                                    error: error
+                                });
+                                throw error;
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "preloadRemote",
+            value: // eslint-disable-next-line @typescript-eslint/member-ordering
+            function preloadRemote(preloadOptions) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var preloadOps;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforePreloadRemote.emit({
+                                        preloadOptions: preloadOptions,
+                                        options: _this.options,
+                                        origin: _this
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                preloadOps = formatPreloadArgs(_this.options.remotes, preloadOptions);
+                                return [
+                                    4,
+                                    Promise.all(preloadOps.map(function() {
+                                        var _ref = _async_to_generator(function(ops) {
+                                            var remote, remoteInfo, _ref, globalSnapshot, remoteSnapshot, assets;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        remote = ops.remote;
+                                                        remoteInfo = getRemoteInfo(remote);
+                                                        return [
+                                                            4,
+                                                            _this.snapshotHandler.loadRemoteSnapshotInfo(remote)
+                                                        ];
+                                                    case 1:
+                                                        _ref = _state.sent(), globalSnapshot = _ref.globalSnapshot, remoteSnapshot = _ref.remoteSnapshot;
+                                                        return [
+                                                            4,
+                                                            _this.hooks.lifecycle.generatePreloadAssets.emit({
+                                                                origin: _this,
+                                                                preloadOptions: ops,
+                                                                remote: remote,
+                                                                remoteInfo: remoteInfo,
+                                                                globalSnapshot: globalSnapshot,
+                                                                remoteSnapshot: remoteSnapshot
+                                                            })
+                                                        ];
+                                                    case 2:
+                                                        assets = _state.sent();
+                                                        if (!assets) {
+                                                            return [
+                                                                2
+                                                            ];
+                                                        }
+                                                        preloadAssets(remoteInfo, _this, assets);
+                                                        return [
+                                                            2
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(ops) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            /**
+   * The sharing init sequence function (only runs once per share scope).
+   * Has one argument, the name of the share scope.
+   * Creates a share scope if not existing
+   */ // eslint-disable-next-line @typescript-eslint/member-ordering
+            key: "initializeSharing",
+            value: function initializeSharing() {
+                var shareScopeName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_SCOPE;
+                var _this = this;
+                var shareScopeLoading = Global.__FEDERATION__.__SHARE_SCOPE_LOADING__;
+                var shareScope = Global.__FEDERATION__.__SHARE__;
+                var hostName = this.options.name;
+                // only runs once
+                if (shareScopeLoading[shareScopeName]) {
+                    return shareScopeLoading[shareScopeName];
+                }
+                // creates a new share scope if needed
+                if (!shareScope[shareScopeName]) {
+                    shareScope[shareScopeName] = {};
+                }
+                // runs all init snippets from all modules reachable
+                var scope = shareScope[shareScopeName];
+                var register = function(name1, shared) {
+                    var version = shared.version, eager = shared.eager;
+                    scope[name1] = scope[name1] || {};
+                    var versions = scope[name1];
+                    var activeVersion = versions[version];
+                    var activeVersionEager = Boolean(activeVersion && (activeVersion.eager || activeVersion.shareConfig.eager));
+                    if (!activeVersion || !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > activeVersion.from)) {
+                        versions[version] = shared;
+                    }
+                };
+                var promises = [];
+                var _this1 = this;
+                var initRemoteModule = function() {
+                    var _ref = _async_to_generator(function(key) {
+                        var module, initFn, entry;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        _this1._getRemoteModuleAndOptions(key)
+                                    ];
+                                case 1:
+                                    module = _state.sent().module;
+                                    initFn = function(mod) {
+                                        return mod && mod.init && mod.init(shareScope[shareScopeName]);
+                                    };
+                                    return [
+                                        4,
+                                        module.getEntry()
+                                    ];
+                                case 2:
+                                    entry = _state.sent();
+                                    initFn(entry);
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    });
+                    return function initRemoteModule(key) {
+                        return _ref.apply(this, arguments);
+                    };
+                }();
+                Object.keys(this.options.shared).forEach(function(shareName) {
+                    var shared = _this.options.shared[shareName];
+                    if (shared.scope.includes(shareScopeName)) {
+                        register(shareName, shared);
+                    }
+                });
+                this.options.remotes.forEach(function(remote) {
+                    if (remote.shareScope === shareScopeName) {
+                        promises.push(initRemoteModule(remote.name));
+                    }
+                });
+                if (!promises.length) {
+                    return shareScopeLoading[shareScopeName] = true;
+                }
+                return shareScopeLoading[shareScopeName] = Promise.all(promises).then(function() {
+                    return shareScopeLoading[shareScopeName] = true;
+                });
+            }
+        },
+        {
+            key: "formatOptions",
+            value: function formatOptions(globalOptions, userOptions) {
+                var _this = this;
+                var formatShareOptions = formatShareConfigs(userOptions.shared || {}, userOptions.name);
+                var shared = _extends({}, globalOptions.shared, formatShareOptions);
+                var _this_hooks_lifecycle_beforeInit_emit = this.hooks.lifecycle.beforeInit.emit({
+                    origin: this,
+                    userOptions: userOptions,
+                    options: globalOptions,
+                    shareInfo: shared
+                }), userOptionsRes = _this_hooks_lifecycle_beforeInit_emit.userOptions, globalOptionsRes = _this_hooks_lifecycle_beforeInit_emit.options;
+                var userRemotes = userOptionsRes.remotes || [];
+                var remotes = userRemotes.reduce(function(res, remote) {
+                    if (!res.find(function(item) {
+                        return item.name === remote.name;
+                    })) {
+                        if (remote.alias) {
+                            // 校验 alias 是否等于 remote.name 和 remote.alias 的前缀，如果是则报错
+                            // 因为引用支持多级路径的引用时无法保证名称是否唯一，所以不支持 alias 为 remote.name 的前缀
+                            var findEqual = res.find(function(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 ".concat(remote.alias, " of remote ").concat(remote.name, " is not allowed to be the prefix of ").concat(findEqual && findEqual.name, " name or alias"));
+                        }
+                        // Set the remote entry to a complete path
+                        if ("entry" in remote) {
+                            if (isBrowserEnv$1()) {
+                                remote.entry = new URL(remote.entry, window.location.origin).href;
+                            }
+                        }
+                        if (!remote.shareScope) {
+                            remote.shareScope = DEFAULT_SCOPE;
+                        }
+                        if (!remote.type) {
+                            // FIXME: The build plugin need to support this field
+                            remote.type = DEFAULT_REMOTE_TYPE;
+                        }
+                        res.push(remote);
+                    }
+                    return res;
+                }, globalOptionsRes.remotes);
+                // register shared include lib
+                var sharedKeys = Object.keys(formatShareOptions);
+                sharedKeys.forEach(function(sharedKey) {
+                    var sharedVal = formatShareOptions[sharedKey];
+                    var globalShare = getGlobalShare(sharedKey, sharedVal);
+                    if (!globalShare && sharedVal && sharedVal.lib) {
+                        _this.setShared({
+                            pkgName: sharedKey,
+                            lib: sharedVal.lib,
+                            get: sharedVal.get,
+                            shared: sharedVal,
+                            from: userOptions.name
+                        });
+                    }
+                });
+                var plugins = _to_consumable_array(globalOptionsRes.plugins);
+                if (userOptionsRes.plugins) {
+                    userOptionsRes.plugins.forEach(function(plugin) {
+                        if (!plugins.includes(plugin)) {
+                            plugins.push(plugin);
+                        }
+                    });
+                }
+                var optionsRes = _extends({}, globalOptions, userOptions, {
+                    plugins: plugins,
+                    remotes: remotes,
+                    shared: shared
+                });
+                this.hooks.lifecycle.init.emit({
+                    origin: this,
+                    options: optionsRes
+                });
+                return optionsRes;
+            }
+        },
+        {
+            key: "registerPlugins",
+            value: function registerPlugins1(plugins) {
+                registerPlugins(plugins, [
+                    this.hooks,
+                    this.snapshotHandler.hooks,
+                    this.loaderHook
+                ]);
+            }
+        },
+        {
+            key: "setShared",
+            value: function setShared(param) {
+                var pkgName = param.pkgName, shared = param.shared; param.from; var lib = param.lib, loading = param.loading, loaded = param.loaded, get = param.get;
+                var target = getGlobalShareScope();
+                var version = shared.version, _shared_scope = shared.scope, scope = _shared_scope === void 0 ? "default" : _shared_scope, shareInfo = _object_without_properties_loose(shared, [
+                    "version",
+                    "scope"
+                ]);
+                var scopes = Array.isArray(scope) ? scope : [
+                    scope
+                ];
+                scopes.forEach(function(sc) {
+                    if (!target[sc]) {
+                        target[sc] = {};
+                    }
+                    if (!target[sc][pkgName]) {
+                        target[sc][pkgName] = {};
+                    }
+                    if (target[sc][pkgName][version]) {
+                        warn("The share \n ".concat(safeToString$1({
+                            scope: sc,
+                            pkgName: pkgName,
+                            version: version,
+                            from: target[sc][pkgName][version].from
+                        }), " has been registered"));
+                        return;
+                    }
+                    target[sc][pkgName][version] = _extends({
+                        version: version,
+                        scope: [
+                            "default"
+                        ]
+                    }, shareInfo, {
+                        lib: lib,
+                        loaded: loaded,
+                        loading: loading
+                    });
+                    if (get) {
+                        target[sc][pkgName][version].get = get;
+                    }
+                });
+            }
+        }
+    ]);
+    return FederationHost;
+}();
+var FederationInstance = null;
+function init(options) {
+    // Retrieve the same instance with the same name
+    var instance = getGlobalFederationInstance(options.name, options.version);
+    if (!instance) {
+        // Retrieve debug constructor
+        var FederationConstructor = getGlobalFederationConstructor() || FederationHost;
+        FederationInstance = new FederationConstructor(options);
+        setGlobalFederationInstance(FederationInstance);
+        return FederationInstance;
+    } else {
+        // Merge options
+        instance.initOptions(options);
+        return instance;
+    }
+}
+function loadRemote() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    assert(FederationInstance, "Please call init first");
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadRemote.apply(FederationInstance, args);
+}
+function loadShare() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    assert(FederationInstance, "Please call init first");
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadShare.apply(FederationInstance, args);
+}
+function loadShareSync() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    assert(FederationInstance, "Please call init first");
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadShareSync.apply(FederationInstance, args);
+}
+function preloadRemote() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    assert(FederationInstance, "Please call init first");
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.preloadRemote.apply(FederationInstance, args);
+}
+// Inject for debug
+setGlobalFederationConstructor(FederationHost);
+
+var runtime = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FederationHost: FederationHost,
+    init: init,
+    loadRemote: loadRemote,
+    loadScript: loadScript,
+    loadShare: loadShare,
+    loadShareSync: loadShareSync,
+    preloadRemote: preloadRemote,
+    registerGlobalPlugins: registerGlobalPlugins
+});
+
+function remotes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, idToExternalAndNameMapping = options.idToExternalAndNameMapping, webpackRequire = options.webpackRequire;
+    if (webpackRequire.o(chunkMapping, chunkId)) {
+        chunkMapping[chunkId].forEach(function(id) {
+            var getScope = webpackRequire.R;
+            if (!getScope) {
+                getScope = [];
+            }
+            var data = idToExternalAndNameMapping[id];
+            // @ts-ignore seems not work
+            if (getScope.indexOf(data) >= 0) {
+                return;
+            }
+            // @ts-ignore seems not work
+            getScope.push(data);
+            if (data.p) {
+                return promises.push(data.p);
+            }
+            var onError = function(error) {
+                if (!error) {
+                    error = new Error("Container missing");
+                }
+                if (typeof error.message === "string") {
+                    error.message += '\nwhile loading "'.concat(data[1], '" from ').concat(data[2]);
+                }
+                webpackRequire.m[id] = function() {
+                    throw error;
+                };
+                data.p = 0;
+            };
+            var handleFunction = function(fn, arg1, arg2, d, next, first) {
+                try {
+                    var promise = fn(arg1, arg2);
+                    if (promise && promise.then) {
+                        var p = promise.then(function(result) {
+                            return next(result, d);
+                        }, onError);
+                        if (first) {
+                            promises.push(data.p = p);
+                        } else {
+                            return p;
+                        }
+                    } else {
+                        return next(promise, d, first);
+                    }
+                } catch (error) {
+                    onError(error);
+                }
+            };
+            var onExternal = function(external, _, first) {
+                return external ? handleFunction(webpackRequire.I, data[0], 0, external, onInitialized, first) : onError();
+            };
+            // eslint-disable-next-line no-var
+            var onInitialized = function(_, external, first) {
+                return handleFunction(external.get, data[1], getScope, 0, onFactory, first);
+            };
+            var useRuntimeLoad = [
+                "script"
+            ].includes(data[3]) && data[4];
+            // eslint-disable-next-line no-var
+            var onFactory = function(factory) {
+                data.p = 1;
+                webpackRequire.m[id] = function(module) {
+                    module.exports = factory();
+                };
+            };
+            var onRemoteLoaded = function() {
+                try {
+                    var remoteModuleName = data[4] + data[1].slice(1);
+                    return webpackRequire.federation.instance.loadRemote(remoteModuleName, {
+                        loadFactory: false
+                    });
+                } catch (error) {
+                    onError(error);
+                }
+            };
+            if (useRuntimeLoad) {
+                handleFunction(onRemoteLoaded, data[2], 0, 0, onFactory, 1);
+            } else {
+                handleFunction(webpackRequire, data[2], 0, 0, onExternal, 1);
+            }
+        });
+    }
+}
+
+function proxyShareScopeMap(__webpack_require__) {
+    if (!__webpack_require__.S) {
+        return;
+    }
+    // @ts-ignore FIXME: ideal situation is import type from @module-federation/runtime/type ,but the compile will throw error
+    __webpack_require__.S = new Proxy(globalThis.__VMOK__.__SHARE__, {
+        get: function get(target, prop, receiver) {
+            return globalThis.__VMOK__.__SHARE__[prop];
+        },
+        set: function set(target, prop, value) {
+            globalThis.__VMOK__.__SHARE__[prop] = value;
+            return true;
+        }
+    });
+}
+
+function consumes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, installedModules = options.installedModules, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    proxyShareScopeMap(webpackRequire);
+    if (webpackRequire.o(chunkMapping, chunkId)) {
+        chunkMapping[chunkId].forEach(function(id) {
+            if (webpackRequire.o(installedModules, id)) {
+                return promises.push(installedModules[id]);
+            }
+            var onFactory = function(factory) {
+                installedModules[id] = 0;
+                webpackRequire.m[id] = function(module) {
+                    delete webpackRequire.c[id];
+                    module.exports = factory();
+                };
+            };
+            var onError = function(error) {
+                delete installedModules[id];
+                webpackRequire.m[id] = function(module) {
+                    delete webpackRequire.c[id];
+                    throw error;
+                };
+            };
+            try {
+                var federationInstance = webpackRequire.federation.instance;
+                if (!federationInstance) {
+                    throw new Error("Can not find federation Instance!");
+                }
+                var _moduleToHandlerMapping_id = moduleToHandlerMapping[id], shareKey = _moduleToHandlerMapping_id.shareKey, getter = _moduleToHandlerMapping_id.getter, shareInfo = _moduleToHandlerMapping_id.shareInfo;
+                var promise = federationInstance.loadShare(shareKey, shareInfo).then(function(factory) {
+                    if (factory === false) {
+                        return getter();
+                    }
+                    return factory;
+                });
+                if (promise.then) {
+                    promises.push(installedModules[id] = promise.then(onFactory).catch(onError));
+                } else {
+                    // @ts-ignore keep prev logic
+                    onFactory(promise);
+                }
+            } catch (e) {
+                onError(e);
+            }
+        });
+    }
+}
+
+function initializeSharing(shareScopeName, webpackRequire) {
+    return webpackRequire.federation.instance.initializeSharing(shareScopeName);
+}
+
+function handleInitialConsumes(options) {
+    var moduleId = options.moduleId, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    var federationInstance = webpackRequire.federation.instance;
+    if (!federationInstance) {
+        throw new Error("Can not find federation Instance!");
+    }
+    var _moduleToHandlerMapping_moduleId = moduleToHandlerMapping[moduleId], shareKey = _moduleToHandlerMapping_moduleId.shareKey, shareInfo = _moduleToHandlerMapping_moduleId.shareInfo;
+    if (!shareInfo.shareConfig.eager) {
+        throw new Error('shared: "'.concat(shareKey, '" can not be loaded synchronous while not set "eager:true" or enable async entry. '));
+    }
+    return federationInstance.loadShareSync(shareKey);
+}
+function installInitialConsumes(options) {
+    var moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire, installedModules = options.installedModules, initialConsumes = options.initialConsumes;
+    initialConsumes.forEach(function(id) {
+        webpackRequire.m[id] = function(module) {
+            // Handle case when module is used sync
+            installedModules[id] = 0;
+            delete webpackRequire.c[id];
+            var factory = handleInitialConsumes({
+                moduleId: id,
+                moduleToHandlerMapping: moduleToHandlerMapping,
+                webpackRequire: webpackRequire
+            });
+            if (typeof factory !== "function") {
+                throw new Error("Shared module is not available for eager consumption: ".concat(id));
+            }
+            module.exports = factory();
+        };
+    });
+}
+
+var federation = {
+    runtime: runtime,
+    instance: undefined,
+    initOptions: undefined,
+    bundlerRuntime: {
+        remotes: remotes,
+        consumes: consumes,
+        I: initializeSharing,
+        S: {},
+        installInitialConsumes: installInitialConsumes
+    }
+};
+
+module.exports = federation;