@module-federation/webpack-bundler-runtime 0.0.0-next-20240822101913 → 0.0.0-next-20240824225724

package/dist/vendored.cjs.js

@@ -0,0 +1,4799 @@
+'use strict';
+
+var _async_to_generator = require('@swc/helpers/_/_async_to_generator');
+var _class_call_check = require('@swc/helpers/_/_class_call_check');
+var _create_class = require('@swc/helpers/_/_create_class');
+var _define_property = require('@swc/helpers/_/_define_property');
+var _inherits = require('@swc/helpers/_/_inherits');
+var _instanceof = require('@swc/helpers/_/_instanceof');
+var _sliced_to_array = require('@swc/helpers/_/_sliced_to_array');
+var _to_consumable_array = require('@swc/helpers/_/_to_consumable_array');
+var _type_of = require('@swc/helpers/_/_type_of');
+var _create_super = require('@swc/helpers/_/_create_super');
+var _ts_generator = require('@swc/helpers/_/_ts_generator');
+var _extends = require('@swc/helpers/_/_extends');
+var _object_without_properties_loose = require('@swc/helpers/_/_object_without_properties_loose');
+require('@swc/helpers/_/_to_array');
+var _object_spread = require('@swc/helpers/_/_object_spread');
+
+var MANIFEST_EXT = '.json';
+var BROWSER_LOG_KEY = 'FEDERATION_DEBUG';
+var BROWSER_LOG_VALUE = '1';
+var NameTransformSymbol = {
+    AT: '@',
+    HYPHEN: '-',
+    SLASH: '/'
+};
+var _obj;
+var NameTransformMap = (_obj = {}, _define_property._(_obj, NameTransformSymbol.AT, 'scope_'), _define_property._(_obj, NameTransformSymbol.HYPHEN, '_'), _define_property._(_obj, NameTransformSymbol.SLASH, '__'), _obj);
+var _obj1;
+var EncodedNameTransformMap = (_obj1 = {}, _define_property._(_obj1, NameTransformMap[NameTransformSymbol.AT], NameTransformSymbol.AT), _define_property._(_obj1, NameTransformMap[NameTransformSymbol.HYPHEN], NameTransformSymbol.HYPHEN), _define_property._(_obj1, NameTransformMap[NameTransformSymbol.SLASH], NameTransformSymbol.SLASH), _obj1);
+var SEPARATOR = ':';
+var ENCODE_NAME_PREFIX = 'ENCODE_NAME_PREFIX';
+Object.freeze({
+    __proto__: null
+});
+Object.freeze({
+    __proto__: null
+});
+Object.freeze({
+    __proto__: null
+});
+Object.freeze({
+    __proto__: null
+});
+function isBrowserEnv() {
+    return typeof window !== 'undefined';
+}
+function isDebugMode() {
+    if (typeof process !== 'undefined' && process.env && process.env['FEDERATION_DEBUG']) {
+        return Boolean(process.env['FEDERATION_DEBUG']);
+    }
+    return typeof FEDERATION_DEBUG !== 'undefined' && Boolean(FEDERATION_DEBUG);
+}
+var DEBUG_LOG = '[ FEDERATION DEBUG ]';
+function safeGetLocalStorageItem() {
+    try {
+        if (typeof window !== 'undefined' && window.localStorage) {
+            return localStorage.getItem(BROWSER_LOG_KEY) === BROWSER_LOG_VALUE;
+        }
+    } catch (error1) {
+        return typeof document !== 'undefined';
+    }
+    return false;
+}
+var Logger = function() {
+    function Logger1(identifier) {
+        _class_call_check._(this, Logger1);
+        this.enable = false;
+        this.identifier = identifier || DEBUG_LOG;
+        if (isBrowserEnv() && safeGetLocalStorageItem()) {
+            this.enable = true;
+        } else if (isDebugMode()) {
+            this.enable = true;
+        }
+    }
+    _create_class._(Logger1, [
+        {
+            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_array._(args));
+                    } else {
+                        var _console1;
+                        console.info("%c ".concat(this.identifier, ": OriginalInfo"), 'color:#3300CC');
+                        (_console1 = console).log.apply(_console1, _to_consumable_array._(args));
+                    }
+                }
+            }
+        }
+    ]);
+    return Logger1;
+}();
+var LOG_CATEGORY$1 = '[ Federation Runtime ]';
+new Logger();
+var composeKeyWithSeparator = function composeKeyWithSeparator1() {
+    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);
+    }, '');
+};
+var decodeName = function decodeName1(name, prefix, withExt) {
+    try {
+        var decodedName = name;
+        if (prefix) {
+            if (!decodedName.startsWith(prefix)) {
+                return decodedName;
+            }
+            decodedName = decodedName.replace(new RegExp(prefix, 'g'), '');
+        }
+        decodedName = decodedName.replace(new RegExp("".concat(NameTransformMap[NameTransformSymbol.AT]), 'g'), EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.AT]]).replace(new RegExp("".concat(NameTransformMap[NameTransformSymbol.SLASH]), 'g'), EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.SLASH]]).replace(new RegExp("".concat(NameTransformMap[NameTransformSymbol.HYPHEN]), 'g'), EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.HYPHEN]]);
+        if (withExt) {
+            decodedName = decodedName.replace('.js', '');
+        }
+        return decodedName;
+    } catch (err) {
+        throw err;
+    }
+};
+var getResourceUrl = function(module, sourceUrl) {
+    if ('getPublicPath' in module) {
+        var publicPath;
+        if (!module.getPublicPath.startsWith('function')) {
+            publicPath = new Function(module.getPublicPath)();
+        } else {
+            publicPath = new Function('return ' + 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 '';
+    }
+};
+var warn$1 = function(msg) {
+    console.warn("".concat(LOG_CATEGORY$1, ": ").concat(msg));
+};
+function safeToString(info) {
+    try {
+        return JSON.stringify(info, null, 2);
+    } catch (e) {
+        return '';
+    }
+}
+var simpleJoinRemoteEntry = function(rPath, rName) {
+    if (!rPath) {
+        return rName;
+    }
+    var transformPath = function(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);
+};
+function inferAutoPublicPath(url) {
+    return url.replace(/#.*$/, '').replace(/\?.*$/, '').replace(/\/[^\/]+$/, '/');
+}
+function generateSnapshotFromManifest(manifest) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var _manifest_metaData, _manifest_metaData1;
+    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() {
+        if ('publicPath' in manifest.metaData) {
+            if (manifest.metaData.publicPath === 'auto' && version) {
+                return inferAutoPublicPath(version);
+            }
+            return manifest.metaData.publicPath;
+        } else {
+            return manifest.metaData.getPublicPath;
+        }
+    };
+    var overridesKeys = Object.keys(overrides);
+    var remotesInfo = {};
+    if (!Object.keys(remotes).length) {
+        var _manifest_remotes;
+        remotesInfo = ((_manifest_remotes = manifest.remotes) == null ? void 0 : _manifest_remotes.reduce(function(res, next) {
+            var matchedVersion;
+            var name = next.federationContainerName;
+            if (overridesKeys.includes(name)) {
+                matchedVersion = overrides[name];
+            } else {
+                if ('version' in next) {
+                    matchedVersion = next.version;
+                } else {
+                    matchedVersion = next.entry;
+                }
+            }
+            res[name] = {
+                matchedVersion: matchedVersion
+            };
+            return res;
+        }, {})) || {};
+    }
+    Object.keys(remotes).forEach(function(key) {
+        return remotesInfo[key] = {
+            matchedVersion: overridesKeys.includes(key) ? overrides[key] : remotes[key]
+        };
+    });
+    var _manifest_metaData2 = manifest.metaData, _manifest_metaData_remoteEntry = _manifest_metaData2.remoteEntry, remoteEntryPath = _manifest_metaData_remoteEntry.path, remoteEntryName = _manifest_metaData_remoteEntry.name, remoteEntryType = _manifest_metaData_remoteEntry.type, remoteTypes = _manifest_metaData2.types, buildVersion = _manifest_metaData2.buildInfo.buildVersion, globalName = _manifest_metaData2.globalName, ssrRemoteEntry = _manifest_metaData2.ssrRemoteEntry;
+    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),
+        remoteTypesZip: remoteTypes.zip || '',
+        remoteTypesAPI: remoteTypes.api || '',
+        remotesInfo: remotesInfo,
+        shared: manifest == null ? void 0 : manifest.shared.map(function(item) {
+            return {
+                assets: item.assets,
+                sharedName: item.name,
+                version: item.version
+            };
+        }),
+        modules: exposes == null ? void 0 : exposes.map(function(expose) {
+            return {
+                moduleName: expose.name,
+                modulePath: expose.path,
+                assets: expose.assets
+            };
+        })
+    };
+    if ((_manifest_metaData = manifest.metaData) == null ? void 0 : _manifest_metaData.prefetchInterface) {
+        var prefetchInterface = manifest.metaData.prefetchInterface;
+        basicRemoteSnapshot = _extends._({}, basicRemoteSnapshot, {
+            prefetchInterface: prefetchInterface
+        });
+    }
+    if ((_manifest_metaData1 = manifest.metaData) == null ? void 0 : _manifest_metaData1.prefetchEntry) {
+        var _manifest_metaData_prefetchEntry = manifest.metaData.prefetchEntry, path = _manifest_metaData_prefetchEntry.path, name = _manifest_metaData_prefetchEntry.name, type = _manifest_metaData_prefetchEntry.type;
+        basicRemoteSnapshot = _extends._({}, basicRemoteSnapshot, {
+            prefetchEntry: simpleJoinRemoteEntry(path, name),
+            prefetchEntryType: type
+        });
+    }
+    if ('publicPath' in manifest.metaData) {
+        remoteSnapshot = _extends._({}, basicRemoteSnapshot, {
+            publicPath: getPublicPath()
+        });
+    } else {
+        remoteSnapshot = _extends._({}, basicRemoteSnapshot, {
+            getPublicPath: getPublicPath()
+        });
+    }
+    if (ssrRemoteEntry) {
+        var fullSSRRemoteEntry = simpleJoinRemoteEntry(ssrRemoteEntry.path, ssrRemoteEntry.name);
+        remoteSnapshot.ssrRemoteEntry = fullSSRRemoteEntry;
+        remoteSnapshot.ssrRemoteEntryType = 'commonjs-module';
+    }
+    return remoteSnapshot;
+}
+function isManifestProvider(moduleInfo) {
+    if ('remoteEntry' in moduleInfo && moduleInfo.remoteEntry.includes(MANIFEST_EXT)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+function safeWrapper(callback, disableWarn) {
+    return _safeWrapper.apply(this, arguments);
+}
+function _safeWrapper() {
+    _safeWrapper = _async_to_generator._(function(callback, disableWarn) {
+        var res, e;
+        return _ts_generator._(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$1(e);
+                    return [
+                        2
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _safeWrapper.apply(this, arguments);
+}
+function isStaticResourcesEqual(url1, url2) {
+    var REG_EXP = /^(https?:)?\/\//i;
+    var relativeUrl1 = url1.replace(REG_EXP, '').replace(/\/$/, '');
+    var relativeUrl2 = url2.replace(REG_EXP, '').replace(/\/$/, '');
+    return relativeUrl1 === relativeUrl2;
+}
+function createScript(info) {
+    var script = null;
+    var needAttach = true;
+    var timeout = 20000;
+    var timeoutId;
+    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, info.url)) {
+            script = s;
+            needAttach = false;
+            break;
+        }
+    }
+    if (!script) {
+        script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = info.url;
+        var createScriptRes = undefined;
+        if (info.createScriptHook) {
+            createScriptRes = info.createScriptHook(info.url, info.attrs);
+            if (_instanceof._(createScriptRes, HTMLScriptElement)) {
+                script = createScriptRes;
+            } else if ((typeof createScriptRes === "undefined" ? "undefined" : _type_of._(createScriptRes)) === 'object') {
+                if ('script' in createScriptRes && createScriptRes.script) {
+                    script = createScriptRes.script;
+                }
+                if ('timeout' in createScriptRes && createScriptRes.timeout) {
+                    timeout = createScriptRes.timeout;
+                }
+            }
+        }
+        var attrs = info.attrs;
+        if (attrs && !createScriptRes) {
+            Object.keys(attrs).forEach(function(name) {
+                if (script) {
+                    if (name === 'async' || name === 'defer') {
+                        script[name] = attrs[name];
+                    } else if (!script.getAttribute(name)) {
+                        script.setAttribute(name, attrs[name]);
+                    }
+                }
+            });
+        }
+    }
+    var onScriptComplete = function(prev, event) {
+        var _info_cb;
+        clearTimeout(timeoutId);
+        if (script) {
+            script.onerror = null;
+            script.onload = null;
+            safeWrapper(function() {
+                var _info_needDeleteScript = info.needDeleteScript, needDeleteScript = _info_needDeleteScript === void 0 ? true : _info_needDeleteScript;
+                if (needDeleteScript) {
+                    (script == null ? void 0 : script.parentNode) && script.parentNode.removeChild(script);
+                }
+            });
+            if (prev) {
+                var _info_cb1;
+                var res = prev(event);
+                info == null ? void 0 : (_info_cb1 = info.cb) == null ? void 0 : _info_cb1.call(info);
+                return res;
+            }
+        }
+        info == null ? void 0 : (_info_cb = info.cb) == null ? void 0 : _info_cb.call(info);
+    };
+    script.onerror = onScriptComplete.bind(null, script.onerror);
+    script.onload = onScriptComplete.bind(null, script.onload);
+    timeoutId = setTimeout(function() {
+        onScriptComplete(null, new Error('Remote script "'.concat(info.url, '" time-outed.')));
+    }, timeout);
+    return {
+        script: script,
+        needAttach: needAttach
+    };
+}
+function createLink(info) {
+    var link = null;
+    var needAttach = true;
+    var links = document.getElementsByTagName('link');
+    for(var i = 0; i < links.length; i++){
+        var l = links[i];
+        var linkHref = l.getAttribute('href');
+        var linkRef = l.getAttribute('ref');
+        if (linkHref && isStaticResourcesEqual(linkHref, info.url) && linkRef === info.attrs['ref']) {
+            link = l;
+            needAttach = false;
+            break;
+        }
+    }
+    if (!link) {
+        link = document.createElement('link');
+        link.setAttribute('href', info.url);
+        var createLinkRes = undefined;
+        var attrs = info.attrs;
+        if (info.createLinkHook) {
+            createLinkRes = info.createLinkHook(info.url, attrs);
+            if (_instanceof._(createLinkRes, HTMLLinkElement)) {
+                link = createLinkRes;
+            }
+        }
+        if (attrs && !createLinkRes) {
+            Object.keys(attrs).forEach(function(name) {
+                if (link && !link.getAttribute(name)) {
+                    link.setAttribute(name, attrs[name]);
+                }
+            });
+        }
+    }
+    var onLinkComplete = function(prev, event) {
+        if (link) {
+            link.onerror = null;
+            link.onload = null;
+            safeWrapper(function() {
+                var _info_needDeleteLink = info.needDeleteLink, needDeleteLink = _info_needDeleteLink === void 0 ? true : _info_needDeleteLink;
+                if (needDeleteLink) {
+                    (link == null ? void 0 : link.parentNode) && link.parentNode.removeChild(link);
+                }
+            });
+            if (prev) {
+                var res = prev(event);
+                info.cb();
+                return res;
+            }
+        }
+        info.cb();
+    };
+    link.onerror = onLinkComplete.bind(null, link.onerror);
+    link.onload = onLinkComplete.bind(null, link.onload);
+    return {
+        link: link,
+        needAttach: needAttach
+    };
+}
+function loadScript(url, info) {
+    var _info_attrs = info.attrs, attrs = _info_attrs === void 0 ? {} : _info_attrs, createScriptHook = info.createScriptHook;
+    return new Promise(function(resolve, _reject) {
+        var _createScript = createScript({
+            url: url,
+            cb: resolve,
+            attrs: _extends._({
+                fetchpriority: 'high'
+            }, attrs),
+            createScriptHook: createScriptHook,
+            needDeleteScript: true
+        }), script = _createScript.script, needAttach = _createScript.needAttach;
+        needAttach && document.head.appendChild(script);
+    });
+}
+function importNodeModule(name) {
+    if (!name) {
+        throw new Error('import specifier is required');
+    }
+    var importModule = new Function('name', "return import(name)");
+    return importModule(name).then(function(res) {
+        return res;
+    }).catch(function(error1) {
+        console.error("Error importing module ".concat(name, ":"), error1);
+        throw error1;
+    });
+}
+var loadNodeFetch = function() {
+    var _ref = _async_to_generator._(function() {
+        var fetchModule;
+        return _ts_generator._(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        importNodeModule('node-fetch')
+                    ];
+                case 1:
+                    fetchModule = _state.sent();
+                    return [
+                        2,
+                        fetchModule.default || fetchModule
+                    ];
+            }
+        });
+    });
+    return function loadNodeFetch1() {
+        return _ref.apply(this, arguments);
+    };
+}();
+var lazyLoaderHookFetch = function() {
+    var _ref = _async_to_generator._(function(input, init) {
+        var loaderHooks, hook, res, fetchFunction, _tmp;
+        return _ts_generator._(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    loaderHooks = __webpack_require__.federation.instance.loaderHook;
+                    hook = function(url, init) {
+                        return loaderHooks.lifecycle.fetch.emit(url, init);
+                    };
+                    return [
+                        4,
+                        hook(input, init || {})
+                    ];
+                case 1:
+                    res = _state.sent();
+                    if (!(!res || !_instanceof._(res, Response))) return [
+                        3,
+                        5
+                    ];
+                    if (!(typeof fetch === 'undefined')) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        loadNodeFetch()
+                    ];
+                case 2:
+                    _tmp = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    _tmp = fetch;
+                    _state.label = 4;
+                case 4:
+                    fetchFunction = _tmp;
+                    return [
+                        2,
+                        fetchFunction(input, init || {})
+                    ];
+                case 5:
+                    return [
+                        2,
+                        res
+                    ];
+            }
+        });
+    });
+    return function lazyLoaderHookFetch1(input, init) {
+        return _ref.apply(this, arguments);
+    };
+}();
+function createScriptNode(url, cb, attrs, createScriptHook) {
+    if (createScriptHook) {
+        var hookResult = createScriptHook(url);
+        if (hookResult && (typeof hookResult === "undefined" ? "undefined" : _type_of._(hookResult)) === 'object' && 'url' in hookResult) {
+            url = hookResult.url;
+        }
+    }
+    var urlObj;
+    try {
+        urlObj = new URL(url);
+    } catch (e) {
+        console.error('Error constructing URL:', e);
+        cb(new Error("Invalid URL: ".concat(e)));
+        return;
+    }
+    var getFetch = function() {
+        var _ref = _async_to_generator._(function() {
+            var loaderHooks;
+            return _ts_generator._(this, function(_state) {
+                if (typeof __webpack_require__ !== 'undefined') {
+                    try {
+                        loaderHooks = __webpack_require__.federation.instance.loaderHook;
+                        if (loaderHooks.lifecycle.fetch) {
+                            return [
+                                2,
+                                lazyLoaderHookFetch
+                            ];
+                        }
+                    } catch (e) {
+                        console.warn('federation.instance.loaderHook.lifecycle.fetch failed:', e);
+                    }
+                }
+                return [
+                    2,
+                    typeof fetch === 'undefined' ? loadNodeFetch() : fetch
+                ];
+            });
+        });
+        return function getFetch() {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var handleScriptFetch = function() {
+        var _ref = _async_to_generator._(function(f, urlObj) {
+            var _vm_constants, res, data, _ref, path, vm, scriptContext, urlDirname, filename, _vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER, script, exportedInterface, container, e;
+            return _ts_generator._(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            4,
+                            ,
+                            5
+                        ]);
+                        return [
+                            4,
+                            f(urlObj.href)
+                        ];
+                    case 1:
+                        res = _state.sent();
+                        return [
+                            4,
+                            res.text()
+                        ];
+                    case 2:
+                        data = _state.sent();
+                        return [
+                            4,
+                            Promise.all([
+                                importNodeModule('path'),
+                                importNodeModule('vm')
+                            ])
+                        ];
+                    case 3:
+                        _ref = _sliced_to_array._.apply(void 0, [
+                            _state.sent(),
+                            2
+                        ]), path = _ref[0], vm = _ref[1];
+                        scriptContext = {
+                            exports: {},
+                            module: {
+                                exports: {}
+                            }
+                        };
+                        urlDirname = urlObj.pathname.split('/').slice(0, -1).join('/');
+                        filename = path.basename(urlObj.pathname);
+                        script = new vm.Script("(function(exports, module, require, __dirname, __filename) {".concat(data, "\n})"), {
+                            filename: filename,
+                            importModuleDynamically: (_vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER = (_vm_constants = vm.constants) == null ? void 0 : _vm_constants.USE_MAIN_CONTEXT_DEFAULT_LOADER) != null ? _vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER : importNodeModule
+                        });
+                        script.runInThisContext()(scriptContext.exports, scriptContext.module, eval('require'), urlDirname, filename);
+                        exportedInterface = scriptContext.module.exports || scriptContext.exports;
+                        if (attrs && exportedInterface && attrs['globalName']) {
+                            container = exportedInterface[attrs['globalName']] || exportedInterface;
+                            cb(undefined, container);
+                            return [
+                                2
+                            ];
+                        }
+                        cb(undefined, exportedInterface);
+                        return [
+                            3,
+                            5
+                        ];
+                    case 4:
+                        e = _state.sent();
+                        cb(_instanceof._(e, Error) ? e : new Error("Script execution error: ".concat(e)));
+                        return [
+                            3,
+                            5
+                        ];
+                    case 5:
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        return function handleScriptFetch(f, urlObj) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    getFetch().then(function(f) {
+        return handleScriptFetch(f, urlObj);
+    }).catch(function(err) {
+        cb(err);
+    });
+}
+function loadScriptNode(url, info) {
+    return new Promise(function(resolve, reject) {
+        createScriptNode(url, function(error1, scriptContext) {
+            if (error1) {
+                reject(error1);
+            } else {
+                var _info_attrs, _info_attrs1;
+                var remoteEntryKey = (info == null ? void 0 : (_info_attrs = info.attrs) == null ? void 0 : _info_attrs['globalName']) || "__FEDERATION_".concat(info == null ? void 0 : (_info_attrs1 = info.attrs) == null ? void 0 : _info_attrs1['name'], ":custom__");
+                var entryExports = globalThis[remoteEntryKey] = scriptContext;
+                resolve(entryExports);
+            }
+        }, info.attrs, info.createScriptHook);
+    });
+}
+
+function getBuilderId() {
+    return typeof FEDERATION_BUILD_IDENTIFIER !== 'undefined' ? FEDERATION_BUILD_IDENTIFIER : '';
+}
+var LOG_CATEGORY = '[ Federation Runtime ]';
+function assert(condition, msg) {
+    if (!condition) {
+        error(msg);
+    }
+}
+function error(msg) {
+    if (_instanceof._(msg, Error)) {
+        msg.message = "".concat(LOG_CATEGORY, ": ").concat(msg.message);
+        throw msg;
+    }
+    throw new Error("".concat(LOG_CATEGORY, ": ").concat(msg));
+}
+function warn(msg) {
+    if (_instanceof._(msg, Error)) {
+        msg.message = "".concat(LOG_CATEGORY, ": ").concat(msg.message);
+        console.warn(msg);
+    } else {
+        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.includes('.json') && remote.entry.includes('.js');
+}
+function isObject(val) {
+    return val && (typeof val === "undefined" ? "undefined" : _type_of._(val)) === 'object';
+}
+var objectToString = Object.prototype.toString;
+function isPlainObject(val) {
+    return objectToString.call(val) === '[object Object]';
+}
+function arrayOptions(options) {
+    return Array.isArray(options) ? options : [
+        options
+    ];
+}
+function getRemoteEntryInfoFromSnapshot(snapshot) {
+    var defaultRemoteEntryInfo = {
+        url: '',
+        type: 'global',
+        globalName: ''
+    };
+    if (isBrowserEnv()) {
+        return 'remoteEntry' in snapshot ? {
+            url: snapshot.remoteEntry,
+            type: snapshot.remoteEntryType,
+            globalName: snapshot.globalName
+        } : defaultRemoteEntryInfo;
+    }
+    if ('ssrRemoteEntry' in snapshot) {
+        return {
+            url: snapshot.ssrRemoteEntry || defaultRemoteEntryInfo.url,
+            type: snapshot.ssrRemoteEntryType || defaultRemoteEntryInfo.type,
+            globalName: snapshot.globalName
+        };
+    }
+    return defaultRemoteEntryInfo;
+}
+var nativeGlobal = function() {
+    try {
+        return new Function('return this')();
+    } catch (e) {
+        return globalThis;
+    }
+}();
+var Global = nativeGlobal;
+function definePropertyGlobalVal(target, key, val) {
+    Object.defineProperty(target, key, {
+        value: val,
+        configurable: false,
+        writable: true
+    });
+}
+function includeOwnProperty(target, key) {
+    return Object.hasOwnProperty.call(target, key);
+}
+if (!includeOwnProperty(globalThis, '__GLOBAL_LOADING_REMOTE_ENTRY__')) {
+    definePropertyGlobalVal(globalThis, '__GLOBAL_LOADING_REMOTE_ENTRY__', {});
+}
+var globalLoading = globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__;
+function setGlobalDefaultVal(target) {
+    var _target___FEDERATION__, _target___FEDERATION__1, _target___FEDERATION__2, _target___FEDERATION__3, _target___FEDERATION__4, _target___FEDERATION__5;
+    if (includeOwnProperty(target, '__VMOK__') && !includeOwnProperty(target, '__FEDERATION__')) {
+        definePropertyGlobalVal(target, '__FEDERATION__', target.__VMOK__);
+    }
+    if (!includeOwnProperty(target, '__FEDERATION__')) {
+        definePropertyGlobalVal(target, '__FEDERATION__', {
+            __GLOBAL_PLUGIN__: [],
+            __INSTANCES__: [],
+            moduleInfo: {},
+            __SHARE__: {},
+            __MANIFEST_LOADING__: {},
+            __PRELOADED_MAP__: new Map()
+        });
+        definePropertyGlobalVal(target, '__VMOK__', target.__FEDERATION__);
+    }
+    var ___GLOBAL_PLUGIN__;
+    (___GLOBAL_PLUGIN__ = (_target___FEDERATION__ = target.__FEDERATION__).__GLOBAL_PLUGIN__) != null ? ___GLOBAL_PLUGIN__ : _target___FEDERATION__.__GLOBAL_PLUGIN__ = [];
+    var ___INSTANCES__;
+    (___INSTANCES__ = (_target___FEDERATION__1 = target.__FEDERATION__).__INSTANCES__) != null ? ___INSTANCES__ : _target___FEDERATION__1.__INSTANCES__ = [];
+    var _moduleInfo;
+    (_moduleInfo = (_target___FEDERATION__2 = target.__FEDERATION__).moduleInfo) != null ? _moduleInfo : _target___FEDERATION__2.moduleInfo = {};
+    var ___SHARE__;
+    (___SHARE__ = (_target___FEDERATION__3 = target.__FEDERATION__).__SHARE__) != null ? ___SHARE__ : _target___FEDERATION__3.__SHARE__ = {};
+    var ___MANIFEST_LOADING__;
+    (___MANIFEST_LOADING__ = (_target___FEDERATION__4 = target.__FEDERATION__).__MANIFEST_LOADING__) != null ? ___MANIFEST_LOADING__ : _target___FEDERATION__4.__MANIFEST_LOADING__ = {};
+    var ___PRELOADED_MAP__;
+    (___PRELOADED_MAP__ = (_target___FEDERATION__5 = target.__FEDERATION__).__PRELOADED_MAP__) != null ? ___PRELOADED_MAP__ : _target___FEDERATION__5.__PRELOADED_MAP__ = new Map();
+}
+setGlobalDefaultVal(globalThis);
+setGlobalDefaultVal(nativeGlobal);
+function getGlobalFederationInstance(name, version) {
+    var buildId = getBuilderId();
+    return globalThis.__FEDERATION__.__INSTANCES__.find(function(GMInstance) {
+        if (buildId && GMInstance.options.id === getBuilderId()) {
+            return true;
+        }
+        if (GMInstance.options.name === name && !GMInstance.options.version && !version) {
+            return true;
+        }
+        if (GMInstance.options.name === name && version && GMInstance.options.version === version) {
+            return true;
+        }
+        return false;
+    });
+}
+function setGlobalFederationInstance(FederationInstance) {
+    globalThis.__FEDERATION__.__INSTANCES__.push(FederationInstance);
+}
+function getGlobalFederationConstructor() {
+    return globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR__;
+}
+function setGlobalFederationConstructor(FederationConstructor) {
+    var isDebug = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : isDebugMode();
+    if (isDebug) {
+        globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
+        globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.5.1";
+    }
+}
+function getInfoWithoutType(target, key) {
+    if (typeof key === 'string') {
+        var keyRes = target[key];
+        if (keyRes) {
+            return {
+                value: target[key],
+                key: key
+            };
+        } else {
+            var targetKeys = Object.keys(target);
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = targetKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var targetKey = _step.value;
+                    var _targetKey_split = _sliced_to_array._(targetKey.split(':'), 2), targetTypeOrName = _targetKey_split[0], _ = _targetKey_split[1];
+                    var nKey = "".concat(targetTypeOrName, ":").concat(key);
+                    var typeWithKeyRes = target[nKey];
+                    if (typeWithKeyRes) {
+                        return {
+                            value: typeWithKeyRes,
+                            key: nKey
+                        };
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            return {
+                value: undefined,
+                key: key
+            };
+        }
+    } else {
+        throw new Error('key must be string');
+    }
+}
+var getGlobalSnapshot = function() {
+    return nativeGlobal.__FEDERATION__.moduleInfo;
+};
+var getTargetSnapshotInfoByModuleInfo = function(moduleInfo, snapshot) {
+    var moduleKey = getFMId(moduleInfo);
+    var getModuleInfo = getInfoWithoutType(snapshot, moduleKey).value;
+    if (getModuleInfo && !getModuleInfo.version && 'version' in moduleInfo && moduleInfo['version']) {
+        getModuleInfo.version = moduleInfo['version'];
+    }
+    if (getModuleInfo) {
+        return getModuleInfo;
+    }
+    if ('version' in moduleInfo && moduleInfo['version']) {
+        var version = moduleInfo.version, resModuleInfo = _object_without_properties_loose._(moduleInfo, [
+            "version"
+        ]);
+        var moduleKeyWithoutVersion = getFMId(resModuleInfo);
+        var getModuleInfoWithoutVersion = getInfoWithoutType(nativeGlobal.__FEDERATION__.moduleInfo, moduleKeyWithoutVersion).value;
+        if ((getModuleInfoWithoutVersion == null ? void 0 : getModuleInfoWithoutVersion.version) === version) {
+            return getModuleInfoWithoutVersion;
+        }
+    }
+    return;
+};
+var getGlobalSnapshotInfoByModuleInfo = function(moduleInfo) {
+    return getTargetSnapshotInfoByModuleInfo(moduleInfo, nativeGlobal.__FEDERATION__.moduleInfo);
+};
+var setGlobalSnapshotInfoByModuleInfo = function(remoteInfo, moduleDetailInfo) {
+    var moduleKey = getFMId(remoteInfo);
+    nativeGlobal.__FEDERATION__.moduleInfo[moduleKey] = moduleDetailInfo;
+    return nativeGlobal.__FEDERATION__.moduleInfo;
+};
+var addGlobalSnapshot = function(moduleInfos) {
+    nativeGlobal.__FEDERATION__.moduleInfo = _extends._({}, nativeGlobal.__FEDERATION__.moduleInfo, moduleInfos);
+    return function() {
+        var keys = Object.keys(moduleInfos);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                delete nativeGlobal.__FEDERATION__.moduleInfo[key];
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    };
+};
+var getRemoteEntryExports = function(name, globalName) {
+    var remoteEntryKey = globalName || "__FEDERATION_".concat(name, ":custom__");
+    var entryExports = globalThis[remoteEntryKey];
+    return {
+        remoteEntryKey: remoteEntryKey,
+        entryExports: entryExports
+    };
+};
+var registerGlobalPlugins = function(plugins) {
+    var __GLOBAL_PLUGIN__ = nativeGlobal.__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 nativeGlobal.__FEDERATION__.__GLOBAL_PLUGIN__;
+};
+var getPreloaded = function(id) {
+    return globalThis.__FEDERATION__.__PRELOADED_MAP__.get(id);
+};
+var setPreloaded = function(id) {
+    return globalThis.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
+};
+var DEFAULT_SCOPE = 'default';
+var DEFAULT_REMOTE_TYPE = 'global';
+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, ")$|^$");
+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 === '<') {
+                    return '<0.0.0-0';
+                } else {
+                    return '*';
+                }
+            } else if (gtlt && isXPatch) {
+                if (isXMinor) {
+                    minor = 0;
+                }
+                patch = 0;
+                if (gtlt === '>') {
+                    gtlt = '>=';
+                    if (isXMinor) {
+                        major = Number(major) + 1;
+                        minor = 0;
+                        patch = 0;
+                    } else {
+                        minor = Number(minor) + 1;
+                        patch = 0;
+                    }
+                } else if (gtlt === '<=') {
+                    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:
+            {
+                return true;
+            }
+        default:
+            return false;
+    }
+}
+function parseComparatorString(range) {
+    return pipe(parseCarets, parseTildes, parseXRanges, parseStar)(range);
+}
+function parseRange(range) {
+    return pipe(parseHyphen, parseComparatorTrim, parseTildeTrim, 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;
+            }
+        }
+    } 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, name, shareStrategy) {
+    var get;
+    if ('get' in shareArgs) {
+        get = shareArgs.get;
+    } else if ('lib' in shareArgs) {
+        get = function() {
+            return Promise.resolve(shareArgs.lib);
+        };
+    } else {
+        get = function() {
+            return Promise.resolve(function() {
+                throw new Error("Can not get shared '".concat(name, "'!"));
+            });
+        };
+    }
+    if (shareArgs.strategy) {
+        warn('"shared.strategy is deprecated, please set in initOptions.shareStrategy instead!"');
+    }
+    var _shareArgs_version, _shareArgs_scope, _shareArgs_strategy;
+    return _extends._({
+        deps: [],
+        useIn: [],
+        from: from,
+        loading: null
+    }, shareArgs, {
+        shareConfig: _extends._({
+            requiredVersion: "^".concat(shareArgs.version),
+            singleton: false,
+            eager: false,
+            strictVersion: false
+        }, shareArgs.shareConfig),
+        get: get,
+        loaded: (shareArgs == null ? void 0 : shareArgs.loaded) || 'lib' in shareArgs ? true : undefined,
+        version: (_shareArgs_version = shareArgs.version) != null ? _shareArgs_version : '0',
+        scope: Array.isArray(shareArgs.scope) ? shareArgs.scope : [
+            (_shareArgs_scope = shareArgs.scope) != null ? _shareArgs_scope : 'default'
+        ],
+        strategy: ((_shareArgs_strategy = shareArgs.strategy) != null ? _shareArgs_strategy : shareStrategy) || 'version-first'
+    });
+}
+function formatShareConfigs(globalOptions, userOptions) {
+    var shareArgs = userOptions.shared || {};
+    var from = userOptions.name;
+    var shareInfos = Object.keys(shareArgs).reduce(function(res, pkgName) {
+        var arrayShareArgs = arrayOptions(shareArgs[pkgName]);
+        res[pkgName] = res[pkgName] || [];
+        arrayShareArgs.forEach(function(shareConfig) {
+            res[pkgName].push(formatShare(shareConfig, from, pkgName, userOptions.shareStrategy));
+        });
+        return res;
+    }, {});
+    var shared = _extends._({}, globalOptions.shared);
+    Object.keys(shareInfos).forEach(function(shareKey) {
+        if (!shared[shareKey]) {
+            shared[shareKey] = shareInfos[shareKey];
+        } else {
+            shareInfos[shareKey].forEach(function(newUserSharedOptions) {
+                var isSameVersion = shared[shareKey].find(function(sharedVal) {
+                    return sharedVal.version === newUserSharedOptions.version;
+                });
+                if (!isSameVersion) {
+                    shared[shareKey].push(newUserSharedOptions);
+                }
+            });
+        }
+    });
+    return {
+        shared: shared,
+        shareInfos: shareInfos
+    };
+}
+function versionLt(a, b) {
+    var transformInvalidVersion = function(version) {
+        var isNumberVersion = !Number.isNaN(Number(version));
+        if (isNumberVersion) {
+            var splitArr = version.split('.');
+            var validVersion = version;
+            for(var i = 0; i < 3 - splitArr.length; i++){
+                validVersion += '.0';
+            }
+            return validVersion;
+        }
+        return version;
+    };
+    if (satisfy(transformInvalidVersion(a), "<=".concat(transformInvalidVersion(b)))) {
+        return true;
+    } else {
+        return false;
+    }
+}
+var findVersion = function(shareVersionMap, cb) {
+    var callback = cb || function(prev, cur) {
+        return versionLt(prev, cur);
+    };
+    return Object.keys(shareVersionMap).reduce(function(prev, cur) {
+        if (!prev) {
+            return cur;
+        }
+        if (callback(prev, cur)) {
+            return cur;
+        }
+        if (prev === '0') {
+            return cur;
+        }
+        return prev;
+    }, 0);
+};
+var isLoaded = function(shared) {
+    return Boolean(shared.loaded) || typeof shared.lib === 'function';
+};
+function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName) {
+    var versions = shareScopeMap[scope][pkgName];
+    var callback = function callback(prev, cur) {
+        return !isLoaded(versions[prev]) && versionLt(prev, cur);
+    };
+    return findVersion(shareScopeMap[scope][pkgName], callback);
+}
+function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
+    var versions = shareScopeMap[scope][pkgName];
+    var callback = function callback(prev, cur) {
+        if (isLoaded(versions[cur])) {
+            if (isLoaded(versions[prev])) {
+                return Boolean(versionLt(prev, cur));
+            } else {
+                return true;
+            }
+        }
+        if (isLoaded(versions[prev])) {
+            return false;
+        }
+        return versionLt(prev, cur);
+    };
+    return findVersion(shareScopeMap[scope][pkgName], callback);
+}
+function getFindShareFunction(strategy) {
+    if (strategy === 'loaded-first') {
+        return findSingletonVersionOrderByLoaded;
+    }
+    return findSingletonVersionOrderByVersion;
+}
+function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare) {
+    if (!localShareScopeMap) {
+        return;
+    }
+    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 {
+        var _loop = function() {
+            var sc = _step.value;
+            if (shareConfig && localShareScopeMap[sc] && localShareScopeMap[sc][pkgName]) {
+                var requiredVersion = shareConfig.requiredVersion;
+                var findShareFunction = getFindShareFunction(strategy);
+                var maxOrSingletonVersion = findShareFunction(localShareScopeMap, sc, pkgName);
+                var defaultResolver = function() {
+                    if (shareConfig.singleton) {
+                        if (typeof requiredVersion === 'string' && !satisfy(maxOrSingletonVersion, requiredVersion)) {
+                            var msg = "Version ".concat(maxOrSingletonVersion, " from ").concat(maxOrSingletonVersion && localShareScopeMap[sc][pkgName][maxOrSingletonVersion].from, " of shared singleton module ").concat(pkgName, " does not satisfy the requirement of ").concat(shareInfo.from, " which needs ").concat(requiredVersion, ")");
+                            if (shareConfig.strictVersion) {
+                                error(msg);
+                            } else {
+                                warn(msg);
+                            }
+                        }
+                        return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                    } else {
+                        if (requiredVersion === false || requiredVersion === '*') {
+                            return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                        }
+                        if (satisfy(maxOrSingletonVersion, requiredVersion)) {
+                            return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                        }
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = Object.entries(localShareScopeMap[sc][pkgName])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var _step_value = _sliced_to_array._(_step.value, 2), versionKey = _step_value[0], versionValue = _step_value[1];
+                                if (satisfy(versionKey, requiredVersion)) {
+                                    return versionValue;
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    }
+                };
+                var params = {
+                    shareScopeMap: localShareScopeMap,
+                    scope: sc,
+                    pkgName: pkgName,
+                    version: maxOrSingletonVersion,
+                    GlobalFederation: Global.__FEDERATION__,
+                    resolver: defaultResolver
+                };
+                var resolveShared = resolveShare.emit(params) || params;
+                return {
+                    v: resolveShared.resolver()
+                };
+            }
+        };
+        for(var _iterator = scopes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _ret = _loop();
+            if (_type_of._(_ret) === "object") return _ret.v;
+        }
+    } 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 getTargetSharedOptions(options) {
+    var pkgName = options.pkgName, extraOptions = options.extraOptions, shareInfos = options.shareInfos;
+    var defaultResolver = function(sharedOptions) {
+        if (!sharedOptions) {
+            return undefined;
+        }
+        var shareVersionMap = {};
+        sharedOptions.forEach(function(shared) {
+            shareVersionMap[shared.version] = shared;
+        });
+        var callback = function callback(prev, cur) {
+            return !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur);
+        };
+        var maxVersion = findVersion(shareVersionMap, callback);
+        return shareVersionMap[maxVersion];
+    };
+    var _extraOptions_resolver;
+    var resolver = (_extraOptions_resolver = extraOptions == null ? void 0 : extraOptions.resolver) != null ? _extraOptions_resolver : defaultResolver;
+    return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions == null ? void 0 : extraOptions.customShareInfo);
+}
+
+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;
+            var isNameMatched = id.startsWith(remote.name);
+            var expose = id.replace(remote.name, '');
+            if (isNameMatched) {
+                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
+                    };
+                }
+            }
+            var isAliasMatched = remote.alias && id.startsWith(remote.alias);
+            var exposeWithAlias = remote.alias && id.replace(remote.alias, '');
+            if (remote.alias && isAliasMatched) {
+                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 isNameMatched = nameOrAlias === remote.name;
+            if (isNameMatched) {
+                return remote;
+            }
+            var isAliasMatched = remote.alias && nameOrAlias === remote.alias;
+            if (isAliasMatched) {
+                return remote;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return;
+}
+function registerPlugins$1(plugins, hookInstances) {
+    var globalPlugins = getGlobalHostPlugins();
+    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.applyPlugin(plugin);
+            });
+        });
+    }
+    return plugins;
+}
+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) {
+                            new Function('callbacks', 'import("'.concat(entry, '").then(callbacks[0]).catch(callbacks[1])'))([
+                                resolve,
+                                reject
+                            ]);
+                        } else {
+                            resolve(remoteEntryExports);
+                        }
+                    } catch (e) {
+                        reject(e);
+                    }
+                })
+            ];
+        });
+    });
+    return _loadEsmEntry.apply(this, arguments);
+}
+function loadSystemJsEntry(_) {
+    return _loadSystemJsEntry.apply(this, arguments);
+}
+function _loadSystemJsEntry() {
+    _loadSystemJsEntry = _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) {
+                            new Function('callbacks', 'System.import("'.concat(entry, '").then(callbacks[0]).catch(callbacks[1])'))([
+                                resolve,
+                                reject
+                            ]);
+                        } else {
+                            resolve(remoteEntryExports);
+                        }
+                    } catch (e) {
+                        reject(e);
+                    }
+                })
+            ];
+        });
+    });
+    return _loadSystemJsEntry.apply(this, arguments);
+}
+function loadEntryScript(_) {
+    return _loadEntryScript.apply(this, arguments);
+}
+function _loadEntryScript() {
+    _loadEntryScript = _async_to_generator._(function(param) {
+        var name, globalName, entry, createScriptHook, _getRemoteEntryExports, remoteEntryExports;
+        return _ts_generator._(this, function(_state) {
+            name = param.name, globalName = param.globalName, entry = param.entry, createScriptHook = param.createScriptHook;
+            _getRemoteEntryExports = getRemoteEntryExports(name, globalName), remoteEntryExports = _getRemoteEntryExports.entryExports;
+            if (remoteEntryExports) {
+                return [
+                    2,
+                    remoteEntryExports
+                ];
+            }
+            return [
+                2,
+                loadScript(entry, {
+                    attrs: {},
+                    createScriptHook: function(url, attrs) {
+                        var res = createScriptHook.emit({
+                            url: url,
+                            attrs: attrs
+                        });
+                        if (!res) return;
+                        if (_instanceof._(res, HTMLScriptElement)) {
+                            return res;
+                        }
+                        if ('script' in res || 'timeout' in res) {
+                            return res;
+                        }
+                        return;
+                    }
+                }).then(function() {
+                    var _getRemoteEntryExports = getRemoteEntryExports(name, globalName), remoteEntryKey = _getRemoteEntryExports.remoteEntryKey, entryExports = _getRemoteEntryExports.entryExports;
+                    assert(entryExports, "\n      Unable to use the ".concat(name, "'s '").concat(entry, "' URL with ").concat(remoteEntryKey, "'s globalName to get remoteEntry exports.\n      Possible reasons could be:\n\n      1. '").concat(entry, "' is not the correct URL, or the remoteEntry resource or name is incorrect.\n\n      2. ").concat(remoteEntryKey, " cannot be used to get remoteEntry exports in the window object.\n    "));
+                    return entryExports;
+                }).catch(function(e) {
+                    throw e;
+                })
+            ];
+        });
+    });
+    return _loadEntryScript.apply(this, arguments);
+}
+function loadEntryDom(_) {
+    return _loadEntryDom.apply(this, arguments);
+}
+function _loadEntryDom() {
+    _loadEntryDom = _async_to_generator._(function(param) {
+        var remoteInfo, remoteEntryExports, createScriptHook, entry, globalName, name, type;
+        return _ts_generator._(this, function(_state) {
+            remoteInfo = param.remoteInfo, remoteEntryExports = param.remoteEntryExports, createScriptHook = param.createScriptHook;
+            entry = remoteInfo.entry, globalName = remoteInfo.entryGlobalName, name = remoteInfo.name, type = remoteInfo.type;
+            switch(type){
+                case 'esm':
+                case 'module':
+                    return [
+                        2,
+                        loadEsmEntry({
+                            entry: entry,
+                            remoteEntryExports: remoteEntryExports
+                        })
+                    ];
+                case 'system':
+                    return [
+                        2,
+                        loadSystemJsEntry({
+                            entry: entry,
+                            remoteEntryExports: remoteEntryExports
+                        })
+                    ];
+                default:
+                    return [
+                        2,
+                        loadEntryScript({
+                            entry: entry,
+                            globalName: globalName,
+                            name: name,
+                            createScriptHook: createScriptHook
+                        })
+                    ];
+            }
+            return [
+                2
+            ];
+        });
+    });
+    return _loadEntryDom.apply(this, arguments);
+}
+function loadEntryNode(_) {
+    return _loadEntryNode.apply(this, arguments);
+}
+function _loadEntryNode() {
+    _loadEntryNode = _async_to_generator._(function(param) {
+        var remoteInfo, createScriptHook, entry, globalName, name, _getRemoteEntryExports, remoteEntryExports;
+        return _ts_generator._(this, function(_state) {
+            remoteInfo = param.remoteInfo, createScriptHook = param.createScriptHook;
+            entry = remoteInfo.entry, globalName = remoteInfo.entryGlobalName, name = remoteInfo.name;
+            _getRemoteEntryExports = getRemoteEntryExports(name, globalName), remoteEntryExports = _getRemoteEntryExports.entryExports;
+            if (remoteEntryExports) {
+                return [
+                    2,
+                    remoteEntryExports
+                ];
+            }
+            return [
+                2,
+                loadScriptNode(entry, {
+                    attrs: {
+                        name: name,
+                        globalName: globalName
+                    },
+                    createScriptHook: function(url, attrs) {
+                        var res = createScriptHook.emit({
+                            url: url,
+                            attrs: attrs
+                        });
+                        if (!res) return;
+                        if ('url' in res) {
+                            return res;
+                        }
+                        return;
+                    }
+                }).then(function() {
+                    var _getRemoteEntryExports = getRemoteEntryExports(name, globalName), remoteEntryKey = _getRemoteEntryExports.remoteEntryKey, entryExports = _getRemoteEntryExports.entryExports;
+                    assert(entryExports, "\n      Unable to use the ".concat(name, "'s '").concat(entry, "' URL with ").concat(remoteEntryKey, "'s globalName to get remoteEntry exports.\n      Possible reasons could be:\n\n      1. '").concat(entry, "' is not the correct URL, or the remoteEntry resource or name is incorrect.\n\n      2. ").concat(remoteEntryKey, " cannot be used to get remoteEntry exports in the window object.\n    "));
+                    return entryExports;
+                }).catch(function(e) {
+                    throw e;
+                })
+            ];
+        });
+    });
+    return _loadEntryNode.apply(this, arguments);
+}
+function getRemoteEntryUniqueKey(remoteInfo) {
+    var entry = remoteInfo.entry, name = remoteInfo.name;
+    return composeKeyWithSeparator(name, entry);
+}
+function getRemoteEntry(_) {
+    return _getRemoteEntry.apply(this, arguments);
+}
+function _getRemoteEntry() {
+    _getRemoteEntry = _async_to_generator._(function(param) {
+        var origin, remoteEntryExports, remoteInfo, uniqueKey, loadEntryHook, createScriptHook;
+        return _ts_generator._(this, function(_state) {
+            origin = param.origin, remoteEntryExports = param.remoteEntryExports, remoteInfo = param.remoteInfo;
+            uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
+            if (remoteEntryExports) {
+                return [
+                    2,
+                    remoteEntryExports
+                ];
+            }
+            if (!globalLoading[uniqueKey]) {
+                loadEntryHook = origin.remoteHandler.hooks.lifecycle.loadEntry;
+                if (loadEntryHook.listeners.size) {
+                    globalLoading[uniqueKey] = loadEntryHook.emit({
+                        createScriptHook: origin.loaderHook.lifecycle.createScript,
+                        remoteInfo: remoteInfo,
+                        remoteEntryExports: remoteEntryExports
+                    }).then(function(res) {
+                        return res || undefined;
+                    });
+                } else {
+                    createScriptHook = origin.loaderHook.lifecycle.createScript;
+                    if (!isBrowserEnv()) {
+                        globalLoading[uniqueKey] = loadEntryNode({
+                            remoteInfo: remoteInfo,
+                            createScriptHook: createScriptHook
+                        });
+                    } else {
+                        globalLoading[uniqueKey] = loadEntryDom({
+                            remoteInfo: remoteInfo,
+                            remoteEntryExports: remoteEntryExports,
+                            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 = function() {
+    function Module(param) {
+        var remoteInfo = param.remoteInfo, host = param.host;
+        _class_call_check._(this, Module);
+        this.inited = false;
+        this.lib = undefined;
+        this.remoteInfo = remoteInfo;
+        this.host = host;
+    }
+    _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({
+                                        origin: _this.host,
+                                        remoteInfo: _this.remoteInfo,
+                                        remoteEntryExports: _this.remoteEntryExports
+                                    })
+                                ];
+                            case 1:
+                                remoteEntryExports = _state.sent();
+                                assert(remoteEntryExports, "remoteEntryExports is undefined \n ".concat(safeToString(_this.remoteInfo)));
+                                _this.remoteEntryExports = remoteEntryExports;
+                                return [
+                                    2,
+                                    _this.remoteEntryExports
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "get",
+            value: function get(id, expose, options) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    var _ref, _ref_loadFactory, loadFactory, remoteEntryExports, localShareScopeMap, remoteShareScope, shareScope, initScope, remoteEntryInitOptions, initContainerOptions, moduleFactory, wrapModuleFactory, 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) return [
+                                    3,
+                                    5
+                                ];
+                                localShareScopeMap = _this.host.shareScopeMap;
+                                remoteShareScope = _this.remoteInfo.shareScope || 'default';
+                                if (!localShareScopeMap[remoteShareScope]) {
+                                    localShareScopeMap[remoteShareScope] = {};
+                                }
+                                shareScope = localShareScopeMap[remoteShareScope];
+                                initScope = [];
+                                remoteEntryInitOptions = {
+                                    version: _this.remoteInfo.version || ''
+                                };
+                                Object.defineProperty(remoteEntryInitOptions, 'shareScopeMap', {
+                                    value: localShareScopeMap,
+                                    enumerable: false
+                                });
+                                return [
+                                    4,
+                                    _this.host.hooks.lifecycle.beforeInitContainer.emit({
+                                        shareScope: shareScope,
+                                        remoteEntryInitOptions: remoteEntryInitOptions,
+                                        initScope: initScope,
+                                        remoteInfo: _this.remoteInfo,
+                                        origin: _this.host
+                                    })
+                                ];
+                            case 2:
+                                initContainerOptions = _state.sent();
+                                if (typeof (remoteEntryExports == null ? void 0 : remoteEntryExports.init) === 'undefined') {
+                                    console.error('The remote entry interface does not contain "init"', '\n', 'Ensure the name of this remote is not reserved or in use. Check if anything already exists on window[nameOfRemote]', '\n', 'Ensure that window[nameOfRemote] is returning a {get,init} object.');
+                                }
+                                return [
+                                    4,
+                                    remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions)
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    4,
+                                    _this.host.hooks.lifecycle.initContainer.emit(_extends._({}, initContainerOptions, {
+                                        remoteEntryExports: remoteEntryExports
+                                    }))
+                                ];
+                            case 4:
+                                _state.sent();
+                                _state.label = 5;
+                            case 5:
+                                _this.lib = remoteEntryExports;
+                                _this.inited = true;
+                                return [
+                                    4,
+                                    remoteEntryExports.get(expose)
+                                ];
+                            case 6:
+                                moduleFactory = _state.sent();
+                                assert(moduleFactory, "".concat(getFMId(_this.remoteInfo), " remote don't export ").concat(expose, "."));
+                                wrapModuleFactory = _this.wraperFactory(moduleFactory, id);
+                                if (!loadFactory) {
+                                    return [
+                                        2,
+                                        wrapModuleFactory
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    wrapModuleFactory()
+                                ];
+                            case 7:
+                                exposeContent = _state.sent();
+                                return [
+                                    2,
+                                    exposeContent
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "wraperFactory",
+            value: function wraperFactory(moduleFactory, id) {
+                function defineModuleId(res, id) {
+                    if (res && (typeof res === "undefined" ? "undefined" : _type_of._(res)) === 'object' && Object.isExtensible(res) && !Object.getOwnPropertyDescriptor(res, Symbol.for('mf_module_id'))) {
+                        Object.defineProperty(res, Symbol.for('mf_module_id'), {
+                            value: id,
+                            enumerable: false
+                        });
+                    }
+                }
+                if (_instanceof._(moduleFactory, Promise)) {
+                    return _async_to_generator._(function() {
+                        var res;
+                        return _ts_generator._(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        moduleFactory()
+                                    ];
+                                case 1:
+                                    res = _state.sent();
+                                    defineModuleId(res, id);
+                                    return [
+                                        2,
+                                        res
+                                    ];
+                            }
+                        });
+                    });
+                } else {
+                    return function() {
+                        var res = moduleFactory();
+                        defineModuleId(res, id);
+                        return res;
+                    };
+                }
+            }
+        }
+    ]);
+    return Module;
+}();
+var SyncHook = 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) {
+                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);
+                    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) {
+                    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 = 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;
+                        } 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);
+function checkReturnData(originalData, returnedData) {
+    if (!isObject(returnedData)) {
+        return false;
+    }
+    if (originalData !== returnedData) {
+        for(var key in originalData){
+            if (!(key in returnedData)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+var SyncWaterfallHook = 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('The data for the "'.concat(this.type, '" hook should 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('A plugin returned an unacceptable value for the "'.concat(this.type, '" type.'));
+                                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 = 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('The response data for the "'.concat(this.type, '" hook 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('A plugin returned an incorrect value for the "'.concat(_this.type, '" type.'));
+                        }
+                        return data;
+                    };
+                    return Promise.resolve(call(data));
+                }
+                return Promise.resolve(data);
+            }
+        }
+    ]);
+    return AsyncWaterfallHook;
+}(SyncHook);
+var PluginSystem = function() {
+    function PluginSystem(lifecycle) {
+        _class_call_check._(this, PluginSystem);
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
+    _create_class._(PluginSystem, [
+        {
+            key: "applyPlugin",
+            value: function applyPlugin(plugin) {
+                var _this = this;
+                assert(isPlainObject(plugin), 'Plugin configuration is invalid.');
+                var pluginName = plugin.name;
+                assert(pluginName, 'A name must be provided by the plugin.');
+                if (!this.registerPlugins[pluginName]) {
+                    this.registerPlugins[pluginName] = plugin;
+                    Object.keys(this.lifecycle).forEach(function(key) {
+                        var pluginLife = plugin[key];
+                        if (pluginLife) {
+                            _this.lifecycle[key].on(pluginLife);
+                        }
+                    });
+                }
+            }
+        },
+        {
+            key: "removePlugin",
+            value: function removePlugin(pluginName) {
+                var _this = this;
+                assert(pluginName, 'A name is required.');
+                var plugin = this.registerPlugins[pluginName];
+                assert(plugin, 'The plugin "'.concat(pluginName, '" is not registered.'));
+                Object.keys(plugin).forEach(function(key) {
+                    if (key !== 'name') {
+                        _this.lifecycle[key].remove(plugin[key]);
+                    }
+                });
+            }
+        },
+        {
+            key: "inherit",
+            value: function inherit(param) {
+                var _this = this;
+                var lifecycle = param.lifecycle, registerPlugins = param.registerPlugins;
+                Object.keys(lifecycle).forEach(function(hookName) {
+                    assert(!_this.lifecycle[hookName], 'The hook "'.concat(hookName, '" has a conflict and cannot be inherited.'));
+                    _this.lifecycle[hookName] = lifecycle[hookName];
+                });
+                Object.keys(registerPlugins).forEach(function(pluginName) {
+                    assert(!_this.registerPlugins[pluginName], 'The plugin "'.concat(pluginName, '" has a conflict and cannot be inherited.'));
+                    _this.applyPlugin(registerPlugins[pluginName]);
+                });
+            }
+        }
+    ]);
+    return PluginSystem;
+}();
+function defaultPreloadArgs(preloadConfig) {
+    return _extends._({
+        resourceCategory: 'sync',
+        share: true,
+        depsRemote: true,
+        prefetchInterface: false
+    }, preloadConfig);
+}
+function formatPreloadArgs(remotes, preloadArgs) {
+    return preloadArgs.map(function(args) {
+        var remoteInfo = matchRemote(remotes, args.nameOrAlias);
+        assert(remoteInfo, "Unable to preload ".concat(args.nameOrAlias, " as it is not included in ").concat(!remoteInfo && safeToString({
+            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 useLinkPreload = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
+    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({
+                    origin: host,
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: module.remoteEntryExports
+                });
+            } else {
+                getRemoteEntry({
+                    origin: host,
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: undefined
+                });
+            }
+        });
+        if (useLinkPreload) {
+            var defaultAttrs = {
+                rel: 'preload',
+                as: 'style',
+                crossorigin: 'anonymous'
+            };
+            cssAssets.forEach(function(cssUrl) {
+                var _createLink = createLink({
+                    url: cssUrl,
+                    cb: function() {},
+                    attrs: defaultAttrs,
+                    createLinkHook: function(url, attrs) {
+                        var res = host.loaderHook.lifecycle.createLink.emit({
+                            url: url,
+                            attrs: attrs
+                        });
+                        if (_instanceof._(res, HTMLLinkElement)) {
+                            return res;
+                        }
+                        return;
+                    }
+                }), cssEl = _createLink.link, needAttach = _createLink.needAttach;
+                needAttach && document.head.appendChild(cssEl);
+            });
+        } else {
+            var defaultAttrs1 = {
+                rel: 'stylesheet',
+                type: 'text/css'
+            };
+            cssAssets.forEach(function(cssUrl) {
+                var _createLink = createLink({
+                    url: cssUrl,
+                    cb: function() {},
+                    attrs: defaultAttrs1,
+                    createLinkHook: function(url, attrs) {
+                        var res = host.loaderHook.lifecycle.createLink.emit({
+                            url: url,
+                            attrs: attrs
+                        });
+                        if (_instanceof._(res, HTMLLinkElement)) {
+                            return res;
+                        }
+                        return;
+                    },
+                    needDeleteLink: false
+                }), cssEl = _createLink.link, needAttach = _createLink.needAttach;
+                needAttach && document.head.appendChild(cssEl);
+            });
+        }
+        if (useLinkPreload) {
+            var defaultAttrs2 = {
+                rel: 'preload',
+                as: 'script',
+                crossorigin: 'anonymous'
+            };
+            jsAssetsWithoutEntry.forEach(function(jsUrl) {
+                var _createLink = createLink({
+                    url: jsUrl,
+                    cb: function() {},
+                    attrs: defaultAttrs2,
+                    createLinkHook: function(url, attrs) {
+                        var res = host.loaderHook.lifecycle.createLink.emit({
+                            url: url,
+                            attrs: attrs
+                        });
+                        if (_instanceof._(res, HTMLLinkElement)) {
+                            return res;
+                        }
+                        return;
+                    }
+                }), linkEl = _createLink.link, needAttach = _createLink.needAttach;
+                needAttach && document.head.appendChild(linkEl);
+            });
+        } else {
+            var defaultAttrs3 = {
+                fetchpriority: 'high',
+                type: (remoteInfo == null ? void 0 : remoteInfo.type) === 'module' ? 'module' : 'text/javascript'
+            };
+            jsAssetsWithoutEntry.forEach(function(jsUrl) {
+                var _createScript = createScript({
+                    url: jsUrl,
+                    cb: function() {},
+                    attrs: defaultAttrs3,
+                    createScriptHook: function(url, attrs) {
+                        var res = host.loaderHook.lifecycle.createScript.emit({
+                            url: url,
+                            attrs: attrs
+                        });
+                        if (_instanceof._(res, HTMLScriptElement)) {
+                            return res;
+                        }
+                        return;
+                    },
+                    needDeleteScript: true
+                }), scriptEl = _createScript.script, needAttach = _createScript.needAttach;
+                needAttach && document.head.appendChild(scriptEl);
+            });
+        }
+    }
+}
+function assignRemoteInfo(remoteInfo, remoteSnapshot) {
+    var remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);
+    if (!remoteEntryInfo.url) {
+        error("The attribute remoteEntry of ".concat(remoteInfo.name, " must not be undefined."));
+    }
+    var entryUrl = getResourceUrl(remoteSnapshot, remoteEntryInfo.url);
+    if (!isBrowserEnv() && !entryUrl.startsWith('http')) {
+        entryUrl = "https:".concat(entryUrl);
+    }
+    remoteInfo.type = remoteEntryInfo.type;
+    remoteInfo.entryGlobalName = remoteEntryInfo.globalName;
+    remoteInfo.entry = entryUrl;
+    remoteInfo.version = remoteSnapshot.version;
+    remoteInfo.buildVersion = remoteSnapshot.buildVersion;
+}
+function snapshotPlugin() {
+    return {
+        name: 'snapshot-plugin',
+        afterResolve: function afterResolve(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);
+                            preloadOptions = {
+                                remote: remote,
+                                preloadConfig: {
+                                    nameOrAlias: pkgNameOrAlias,
+                                    exposes: [
+                                        expose
+                                    ],
+                                    resourceCategory: 'sync',
+                                    share: false,
+                                    depsRemote: false
+                                }
+                            };
+                            return [
+                                4,
+                                origin.remoteHandler.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, false);
+                            }
+                            return [
+                                2,
+                                _extends._({}, args, {
+                                    remoteSnapshot: remoteSnapshot
+                                })
+                            ];
+                        case 3:
+                            return [
+                                2,
+                                args
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+}
+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]
+        };
+    }
+}
+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;
+    var id = getFMId(remoteInfo);
+    var _getInfoWithoutType = getInfoWithoutType(globalSnapshot, id), snapshotValue = _getInfoWithoutType.value;
+    var effectiveRemoteSnapshot = remoteSnapshot || snapshotValue;
+    if (effectiveRemoteSnapshot && !isManifestProvider(effectiveRemoteSnapshot)) {
+        traverse(effectiveRemoteSnapshot, remoteInfo, isRoot);
+        if (effectiveRemoteSnapshot.remotesInfo) {
+            var remoteKeys = Object.keys(effectiveRemoteSnapshot.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 = effectiveRemoteSnapshot.remotesInfo[key];
+                    traverseModuleInfo(globalSnapshot, {
+                        name: subRemoteInfo.name,
+                        version: remoteValue.matchedVersion
+                    }, traverse, false, memo, undefined);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+    }
+}
+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 handleAssets = function handleAssets(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)) {
+                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, getRemoteEntryInfoFromSnapshot(moduleInfoSnapshot).url);
+        if (remoteEntryUrl) {
+            entryAssets.push({
+                name: remoteInfo.name,
+                moduleInfo: {
+                    name: remoteInfo.name,
+                    entry: remoteEntryUrl,
+                    type: 'remoteEntryType' in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntryType : 'global',
+                    entryGlobalName: 'globalName' in moduleInfoSnapshot ? moduleInfoSnapshot.globalName : remoteInfo.name,
+                    shareScope: '',
+                    version: 'version' in moduleInfoSnapshot ? moduleInfoSnapshot.version : 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];
+                var exposeFullPath = "".concat(remoteInfo.name, "/").concat(assetsInfo.moduleName);
+                origin.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({
+                    id: assetsInfo.moduleName === '.' ? remoteInfo.name : exposeFullPath,
+                    name: remoteInfo.name,
+                    remoteSnapshot: moduleInfoSnapshot,
+                    preloadConfig: preloadConfig,
+                    remote: remoteInfo,
+                    origin: origin
+                });
+                var preloaded = getPreloaded(exposeFullPath);
+                if (preloaded) {
+                    continue;
+                }
+                if (preloadConfig.resourceCategory === 'all') {
+                    var _cssAssets, _cssAssets1, _jsAssets, _jsAssets1;
+                    (_cssAssets = cssAssets).push.apply(_cssAssets, _to_consumable_array._(handleAssets(assetsInfo.assets.css.async)));
+                    (_cssAssets1 = cssAssets).push.apply(_cssAssets1, _to_consumable_array._(handleAssets(assetsInfo.assets.css.sync)));
+                    (_jsAssets = jsAssets).push.apply(_jsAssets, _to_consumable_array._(handleAssets(assetsInfo.assets.js.async)));
+                    (_jsAssets1 = jsAssets).push.apply(_jsAssets1, _to_consumable_array._(handleAssets(assetsInfo.assets.js.sync)));
+                } else if (preloadConfig.resourceCategory = 'sync') {
+                    var _cssAssets2, _jsAssets2;
+                    (_cssAssets2 = cssAssets).push.apply(_cssAssets2, _to_consumable_array._(handleAssets(assetsInfo.assets.css.sync)));
+                    (_jsAssets2 = jsAssets).push.apply(_jsAssets2, _to_consumable_array._(handleAssets(assetsInfo.assets.js.sync)));
+                }
+                setPreloaded(exposeFullPath);
+            }
+        }
+    }, true, memo, remoteSnapshot);
+    if (remoteSnapshot.shared) {
+        var collectSharedAssets = function(shareInfo, snapshotShared) {
+            var registeredShared = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare);
+            if (registeredShared && typeof registeredShared.lib === 'function') {
+                snapshotShared.assets.js.sync.forEach(function(asset) {
+                    loadedSharedJsAssets.add(asset);
+                });
+                snapshotShared.assets.css.sync.forEach(function(asset) {
+                    loadedSharedCssAssets.add(asset);
+                });
+            }
+        };
+        remoteSnapshot.shared.forEach(function(shared) {
+            var _options_shared;
+            var shareInfos = (_options_shared = options.shared) == null ? void 0 : _options_shared[shared.sharedName];
+            if (!shareInfos) {
+                return;
+            }
+            var sharedOptions = shared.version ? shareInfos.find(function(s) {
+                return s.version === shared.version;
+            }) : shareInfos;
+            if (!sharedOptions) {
+                return;
+            }
+            var arrayShareInfo = arrayOptions(sharedOptions);
+            arrayShareInfo.forEach(function(s) {
+                collectSharedAssets(s, shared);
+            });
+        });
+    }
+    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
+                    ];
+                });
+            })();
+        }
+    };
+};
+function getGlobalRemoteInfo(moduleInfo, origin) {
+    var hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({
+        name: origin.options.name,
+        version: origin.options.version
+    });
+    var globalRemoteInfo = hostGlobalSnapshot && 'remotesInfo' in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;
+    if (globalRemoteInfo && globalRemoteInfo.matchedVersion) {
+        return {
+            hostGlobalSnapshot: hostGlobalSnapshot,
+            globalSnapshot: getGlobalSnapshot(),
+            remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+                name: moduleInfo.name,
+                version: globalRemoteInfo.matchedVersion
+            })
+        };
+    }
+    return {
+        hostGlobalSnapshot: undefined,
+        globalSnapshot: getGlobalSnapshot(),
+        remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+            name: moduleInfo.name,
+            version: 'version' in moduleInfo ? moduleInfo.version : undefined
+        })
+    };
+}
+var SnapshotHandler = 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;
+        this.loaderHook = HostInstance.loaderHook;
+    }
+    _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: function loadRemoteSnapshotInfo(moduleInfo) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    var options, hostSnapshot, _this_getGlobalRemoteInfo, hostGlobalSnapshot, remoteSnapshot, globalSnapshot, _ref, globalRemoteSnapshot, globalSnapshotRes, remoteEntry, moduleSnapshot, globalSnapshotRes1, _ref1, remoteSnapshotRes, moduleSnapshot1, globalSnapshotRes2, _ref2, remoteSnapshotRes1;
+                    return _ts_generator._(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                options = _this.HostInstance.options;
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
+                                        options: options,
+                                        moduleInfo: moduleInfo
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
+                                    name: _this.HostInstance.options.name,
+                                    version: _this.HostInstance.options.version
+                                });
+                                if (!hostSnapshot) {
+                                    hostSnapshot = {
+                                        version: _this.HostInstance.options.version || '',
+                                        remoteEntry: '',
+                                        remotesInfo: {}
+                                    };
+                                    addGlobalSnapshot(_define_property._({}, _this.HostInstance.options.name, hostSnapshot));
+                                }
+                                if (hostSnapshot && 'remotesInfo' in hostSnapshot && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
+                                    if ('version' in moduleInfo || 'entry' in moduleInfo) {
+                                        hostSnapshot.remotesInfo = _extends._({}, 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
+                                ];
+                                remoteEntry = isBrowserEnv() ? globalRemoteSnapshot.remoteEntry : globalRemoteSnapshot.ssrRemoteEntry || globalRemoteSnapshot.remoteEntry || '';
+                                return [
+                                    4,
+                                    _this.getManifestJson(remoteEntry, moduleInfo, {})
+                                ];
+                            case 3:
+                                moduleSnapshot = _state.sent();
+                                globalSnapshotRes1 = setGlobalSnapshotInfoByModuleInfo(_extends._({}, moduleInfo, {
+                                    entry: remoteEntry
+                                }), 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();
+                                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 getGlobalRemoteInfo1(moduleInfo) {
+                return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
+            }
+        },
+        {
+            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,
+                                                6,
+                                                ,
+                                                7
+                                            ]);
+                                            return [
+                                                4,
+                                                _this.loaderHook.lifecycle.fetch.emit(manifestUrl, {})
+                                            ];
+                                        case 2:
+                                            res = _state.sent();
+                                            if (!(!res || !_instanceof._(res, Response))) return [
+                                                3,
+                                                4
+                                            ];
+                                            return [
+                                                4,
+                                                fetch(manifestUrl, {})
+                                            ];
+                                        case 3:
+                                            res = _state.sent();
+                                            _state.label = 4;
+                                        case 4:
+                                            return [
+                                                4,
+                                                res.json()
+                                            ];
+                                        case 5:
+                                            manifestJson = _state.sent();
+                                            assert(manifestJson.metaData && manifestJson.exposes && manifestJson.shared, "".concat(manifestUrl, " is not a federation manifest"));
+                                            _this.manifestCache.set(manifestUrl, manifestJson);
+                                            return [
+                                                2,
+                                                manifestJson
+                                            ];
+                                        case 6:
+                                            err = _state.sent();
+                                            delete _this.manifestLoading[manifestUrl];
+                                            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,
+                                                7
+                                            ];
+                                        case 7:
+                                            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 SharedHandler = function() {
+    function SharedHandler(host) {
+        _class_call_check._(this, SharedHandler);
+        this.hooks = new PluginSystem({
+            afterResolve: new AsyncWaterfallHook('afterResolve'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
+            loadShare: new AsyncHook(),
+            resolveShare: new SyncWaterfallHook('resolveShare'),
+            initContainerShareScopeMap: new SyncWaterfallHook('initContainerShareScopeMap')
+        });
+        this.host = host;
+        this.shareScopeMap = {};
+        this._setGlobalShareScopeMap(host.options);
+    }
+    _create_class._(SharedHandler, [
+        {
+            key: "registerShared",
+            value: function registerShared(globalOptions, userOptions) {
+                var _this = this;
+                var _formatShareConfigs = formatShareConfigs(globalOptions, userOptions), shareInfos = _formatShareConfigs.shareInfos, shared = _formatShareConfigs.shared;
+                var sharedKeys = Object.keys(shareInfos);
+                sharedKeys.forEach(function(sharedKey) {
+                    var sharedVals = shareInfos[sharedKey];
+                    sharedVals.forEach(function(sharedVal) {
+                        var registeredShared = getRegisteredShare(_this.shareScopeMap, sharedKey, sharedVal, _this.hooks.lifecycle.resolveShare);
+                        if (!registeredShared && sharedVal && sharedVal.lib) {
+                            _this.setShared({
+                                pkgName: sharedKey,
+                                lib: sharedVal.lib,
+                                get: sharedVal.get,
+                                loaded: true,
+                                shared: sharedVal,
+                                from: userOptions.name
+                            });
+                        }
+                    });
+                });
+                return {
+                    shareInfos: shareInfos,
+                    shared: shared
+                };
+            }
+        },
+        {
+            key: "loadShare",
+            value: function loadShare(pkgName, extraOptions) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    var host, shareInfo, loadShareRes, shareInfoRes, registeredShared, addUseIn, factory, asyncLoadProcess, loading, asyncLoadProcess1, loading1;
+                    return _ts_generator._(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                host = _this.host;
+                                shareInfo = getTargetSharedOptions({
+                                    pkgName: pkgName,
+                                    extraOptions: extraOptions,
+                                    shareInfos: host.options.shared
+                                });
+                                if (!(shareInfo == null ? void 0 : shareInfo.scope)) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    Promise.all(shareInfo.scope.map(function() {
+                                        var _ref = _async_to_generator._(function(shareScope) {
+                                            return _ts_generator._(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        return [
+                                                            4,
+                                                            Promise.all(_this.initializeSharing(shareScope, shareInfo.strategy))
+                                                        ];
+                                                    case 1:
+                                                        _state.sent();
+                                                        return [
+                                                            2
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(shareScope) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforeLoadShare.emit({
+                                        pkgName: pkgName,
+                                        shareInfo: shareInfo,
+                                        shared: host.options.shared,
+                                        origin: host
+                                    })
+                                ];
+                            case 3:
+                                loadShareRes = _state.sent();
+                                shareInfoRes = loadShareRes.shareInfo;
+                                assert(shareInfoRes, "Cannot find ".concat(pkgName, " Share in the ").concat(host.options.name, ". Please ensure that the ").concat(pkgName, " Share parameters have been injected"));
+                                registeredShared = getRegisteredShare(_this.shareScopeMap, pkgName, shareInfoRes, _this.hooks.lifecycle.resolveShare);
+                                addUseIn = function(shared) {
+                                    if (!shared.useIn) {
+                                        shared.useIn = [];
+                                    }
+                                    addUniqueItem(shared.useIn, host.options.name);
+                                };
+                                if (!(registeredShared && registeredShared.lib)) return [
+                                    3,
+                                    4
+                                ];
+                                addUseIn(registeredShared);
+                                return [
+                                    2,
+                                    registeredShared.lib
+                                ];
+                            case 4:
+                                if (!(registeredShared && registeredShared.loading && !registeredShared.loaded)) return [
+                                    3,
+                                    6
+                                ];
+                                return [
+                                    4,
+                                    registeredShared.loading
+                                ];
+                            case 5:
+                                factory = _state.sent();
+                                registeredShared.loaded = true;
+                                if (!registeredShared.lib) {
+                                    registeredShared.lib = factory;
+                                }
+                                addUseIn(registeredShared);
+                                return [
+                                    2,
+                                    factory
+                                ];
+                            case 6:
+                                if (registeredShared) {
+                                    asyncLoadProcess = function() {
+                                        var _ref = _async_to_generator._(function() {
+                                            var factory, gShared;
+                                            return _ts_generator._(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        return [
+                                                            4,
+                                                            registeredShared.get()
+                                                        ];
+                                                    case 1:
+                                                        factory = _state.sent();
+                                                        shareInfoRes.lib = factory;
+                                                        shareInfoRes.loaded = true;
+                                                        addUseIn(shareInfoRes);
+                                                        gShared = getRegisteredShare(_this.shareScopeMap, pkgName, shareInfoRes, _this.hooks.lifecycle.resolveShare);
+                                                        if (gShared) {
+                                                            gShared.lib = factory;
+                                                            gShared.loaded = true;
+                                                        }
+                                                        return [
+                                                            2,
+                                                            factory
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function asyncLoadProcess() {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }();
+                                    loading = asyncLoadProcess();
+                                    _this.setShared({
+                                        pkgName: pkgName,
+                                        loaded: false,
+                                        shared: registeredShared,
+                                        from: host.options.name,
+                                        lib: null,
+                                        loading: loading
+                                    });
+                                    return [
+                                        2,
+                                        loading
+                                    ];
+                                } else {
+                                    if (extraOptions == null ? void 0 : extraOptions.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;
+                                                        shareInfoRes.loaded = true;
+                                                        addUseIn(shareInfoRes);
+                                                        gShared = getRegisteredShare(_this.shareScopeMap, pkgName, shareInfoRes, _this.hooks.lifecycle.resolveShare);
+                                                        if (gShared) {
+                                                            gShared.lib = factory;
+                                                            gShared.loaded = true;
+                                                        }
+                                                        return [
+                                                            2,
+                                                            factory
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function asyncLoadProcess1() {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }();
+                                    loading1 = asyncLoadProcess1();
+                                    _this.setShared({
+                                        pkgName: pkgName,
+                                        loaded: false,
+                                        shared: shareInfoRes,
+                                        from: host.options.name,
+                                        lib: null,
+                                        loading: loading1
+                                    });
+                                    return [
+                                        2,
+                                        loading1
+                                    ];
+                                }
+                            case 7:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "initializeSharing",
+            value: function initializeSharing() {
+                var shareScopeName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_SCOPE, strategy = arguments.length > 1 ? arguments[1] : void 0;
+                var host = this.host;
+                var shareScope = this.shareScopeMap;
+                var hostName = host.options.name;
+                if (!shareScope[shareScopeName]) {
+                    shareScope[shareScopeName] = {};
+                }
+                var scope = shareScope[shareScopeName];
+                var register = function(name, shared) {
+                    var _activeVersion_shareConfig;
+                    var version = shared.version, eager = shared.eager;
+                    scope[name] = scope[name] || {};
+                    var versions = scope[name];
+                    var activeVersion = versions[version];
+                    var activeVersionEager = Boolean(activeVersion && (activeVersion.eager || ((_activeVersion_shareConfig = activeVersion.shareConfig) == null ? void 0 : _activeVersion_shareConfig.eager)));
+                    if (!activeVersion || activeVersion.strategy !== 'loaded-first' && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > activeVersion.from)) {
+                        versions[version] = shared;
+                    }
+                };
+                var promises = [];
+                var initFn = function(mod) {
+                    return mod && mod.init && mod.init(shareScope[shareScopeName]);
+                };
+                var initRemoteModule = function() {
+                    var _ref = _async_to_generator._(function(key) {
+                        var module, entry;
+                        return _ts_generator._(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        host.remoteHandler.getRemoteModuleAndOptions({
+                                            id: key
+                                        })
+                                    ];
+                                case 1:
+                                    module = _state.sent().module;
+                                    if (!module.getEntry) return [
+                                        3,
+                                        3
+                                    ];
+                                    return [
+                                        4,
+                                        module.getEntry()
+                                    ];
+                                case 2:
+                                    entry = _state.sent();
+                                    if (!module.inited) {
+                                        initFn(entry);
+                                        module.inited = true;
+                                    }
+                                    _state.label = 3;
+                                case 3:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    });
+                    return function initRemoteModule(key) {
+                        return _ref.apply(this, arguments);
+                    };
+                }();
+                Object.keys(host.options.shared).forEach(function(shareName) {
+                    var sharedArr = host.options.shared[shareName];
+                    sharedArr.forEach(function(shared) {
+                        if (shared.scope.includes(shareScopeName)) {
+                            register(shareName, shared);
+                        }
+                    });
+                });
+                if (host.options.shareStrategy === 'version-first' || strategy === 'version-first') {
+                    host.options.remotes.forEach(function(remote) {
+                        if (remote.shareScope === shareScopeName) {
+                            promises.push(initRemoteModule(remote.name));
+                        }
+                    });
+                }
+                return promises;
+            }
+        },
+        {
+            key: "loadShareSync",
+            value: function loadShareSync(pkgName, extraOptions) {
+                var _this = this;
+                var host = this.host;
+                var shareInfo = getTargetSharedOptions({
+                    pkgName: pkgName,
+                    extraOptions: extraOptions,
+                    shareInfos: host.options.shared
+                });
+                if (shareInfo == null ? void 0 : shareInfo.scope) {
+                    shareInfo.scope.forEach(function(shareScope) {
+                        _this.initializeSharing(shareScope, shareInfo.strategy);
+                    });
+                }
+                var registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareInfo, this.hooks.lifecycle.resolveShare);
+                var addUseIn = function(shared) {
+                    if (!shared.useIn) {
+                        shared.useIn = [];
+                    }
+                    addUniqueItem(shared.useIn, host.options.name);
+                };
+                if (registeredShared) {
+                    if (typeof registeredShared.lib === 'function') {
+                        addUseIn(registeredShared);
+                        if (!registeredShared.loaded) {
+                            registeredShared.loaded = true;
+                            if (registeredShared.from === host.options.name) {
+                                shareInfo.loaded = true;
+                            }
+                        }
+                        return registeredShared.lib;
+                    }
+                    if (typeof registeredShared.get === 'function') {
+                        var module = registeredShared.get();
+                        if (!_instanceof._(module, Promise)) {
+                            addUseIn(registeredShared);
+                            this.setShared({
+                                pkgName: pkgName,
+                                loaded: true,
+                                from: host.options.name,
+                                lib: module,
+                                shared: registeredShared
+                            });
+                            return module;
+                        }
+                    }
+                }
+                if (shareInfo.lib) {
+                    if (!shareInfo.loaded) {
+                        shareInfo.loaded = true;
+                    }
+                    return shareInfo.lib;
+                }
+                if (shareInfo.get) {
+                    var module1 = shareInfo.get();
+                    if (_instanceof._(module1, Promise)) {
+                        throw new Error("\n        The loadShareSync function was unable to load ".concat(pkgName, ". The ").concat(pkgName, " could not be found in ").concat(host.options.name, ".\n        Possible reasons for failure: \n\n        1. The ").concat(pkgName, " share was registered with the 'get' attribute, but loadShare was not used beforehand.\n\n        2. The ").concat(pkgName, " share was not registered with the 'lib' attribute.\n\n      "));
+                    }
+                    shareInfo.lib = module1;
+                    this.setShared({
+                        pkgName: pkgName,
+                        loaded: true,
+                        from: host.options.name,
+                        lib: shareInfo.lib,
+                        shared: shareInfo
+                    });
+                    return shareInfo.lib;
+                }
+                throw new Error("\n        The loadShareSync function was unable to load ".concat(pkgName, ". The ").concat(pkgName, " could not be found in ").concat(host.options.name, ".\n        Possible reasons for failure: \n\n        1. The ").concat(pkgName, " share was registered with the 'get' attribute, but loadShare was not used beforehand.\n\n        2. The ").concat(pkgName, " share was not registered with the 'lib' attribute.\n\n      "));
+            }
+        },
+        {
+            key: "initShareScopeMap",
+            value: function initShareScopeMap(scopeName, shareScope) {
+                var extraOptions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+                var host = this.host;
+                this.shareScopeMap[scopeName] = shareScope;
+                this.hooks.lifecycle.initContainerShareScopeMap.emit({
+                    shareScope: shareScope,
+                    options: host.options,
+                    origin: host,
+                    scopeName: scopeName,
+                    hostShareScopeMap: extraOptions.hostShareScopeMap
+                });
+            }
+        },
+        {
+            key: "setShared",
+            value: function setShared(param) {
+                var _this = this;
+                var pkgName = param.pkgName, shared = param.shared; param.from; var lib = param.lib, loading = param.loading, loaded = param.loaded, get = param.get;
+                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 (!_this.shareScopeMap[sc]) {
+                        _this.shareScopeMap[sc] = {};
+                    }
+                    if (!_this.shareScopeMap[sc][pkgName]) {
+                        _this.shareScopeMap[sc][pkgName] = {};
+                    }
+                    if (_this.shareScopeMap[sc][pkgName][version]) {
+                        return;
+                    }
+                    _this.shareScopeMap[sc][pkgName][version] = _extends._({
+                        version: version,
+                        scope: [
+                            'default'
+                        ]
+                    }, shareInfo, {
+                        lib: lib,
+                        loaded: loaded,
+                        loading: loading
+                    });
+                    if (get) {
+                        _this.shareScopeMap[sc][pkgName][version].get = get;
+                    }
+                });
+            }
+        },
+        {
+            key: "_setGlobalShareScopeMap",
+            value: function _setGlobalShareScopeMap(hostOptions) {
+                var globalShareScopeMap = getGlobalShareScope();
+                var identifier = hostOptions.id || hostOptions.name;
+                if (identifier && !globalShareScopeMap[identifier]) {
+                    globalShareScopeMap[identifier] = this.shareScopeMap;
+                }
+            }
+        }
+    ]);
+    return SharedHandler;
+}();
+var RemoteHandler = function() {
+    function RemoteHandler(host) {
+        _class_call_check._(this, RemoteHandler);
+        this.hooks = new PluginSystem({
+            beforeRegisterRemote: new SyncWaterfallHook('beforeRegisterRemote'),
+            registerRemote: new SyncWaterfallHook('registerRemote'),
+            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
+            onLoad: new AsyncHook('onLoad'),
+            handlePreloadModule: new SyncHook('handlePreloadModule'),
+            errorLoadRemote: new AsyncHook('errorLoadRemote'),
+            beforePreloadRemote: new AsyncHook('beforePreloadRemote'),
+            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
+            afterPreloadRemote: new AsyncHook(),
+            loadEntry: new AsyncHook()
+        });
+        this.host = host;
+        this.idToRemoteMap = {};
+    }
+    _create_class._(RemoteHandler, [
+        {
+            key: "formatAndRegisterRemote",
+            value: function formatAndRegisterRemote(globalOptions, userOptions) {
+                var _this = this;
+                var userRemotes = userOptions.remotes || [];
+                return userRemotes.reduce(function(res, remote) {
+                    _this.registerRemote(remote, res, {
+                        force: false
+                    });
+                    return res;
+                }, globalOptions.remotes);
+            }
+        },
+        {
+            key: "setIdToRemoteMap",
+            value: function setIdToRemoteMap(id, remoteMatchInfo) {
+                var remote = remoteMatchInfo.remote, expose = remoteMatchInfo.expose;
+                var name = remote.name, alias = remote.alias;
+                this.idToRemoteMap[id] = {
+                    name: remote.name,
+                    expose: expose
+                };
+                if (alias && id.startsWith(name)) {
+                    var idWithAlias = id.replace(name, alias);
+                    this.idToRemoteMap[idWithAlias] = {
+                        name: remote.name,
+                        expose: expose
+                    };
+                    return;
+                }
+                if (alias && id.startsWith(alias)) {
+                    var idWithName = id.replace(alias, name);
+                    this.idToRemoteMap[idWithName] = {
+                        name: remote.name,
+                        expose: expose
+                    };
+                }
+            }
+        },
+        {
+            key: "loadRemote",
+            value: function loadRemote(id, options) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    var host, _ref, _ref_loadFactory, loadFactory, _ref1, module, moduleOptions, remoteMatchInfo, pkgNameOrAlias, remote, expose, idRes, moduleOrFactory, moduleWrapper, error, _ref2, _ref_from, from, failOver;
+                    return _ts_generator._(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                host = _this.host;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    5,
+                                    ,
+                                    7
+                                ]);
+                                _ref = options || {
+                                    loadFactory: true
+                                }, _ref_loadFactory = _ref.loadFactory, loadFactory = _ref_loadFactory === void 0 ? true : _ref_loadFactory;
+                                return [
+                                    4,
+                                    _this.getRemoteModuleAndOptions({
+                                        id: id
+                                    })
+                                ];
+                            case 2:
+                                _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(idRes, expose, options)
+                                ];
+                            case 3:
+                                moduleOrFactory = _state.sent();
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.onLoad.emit({
+                                        id: idRes,
+                                        pkgNameOrAlias: pkgNameOrAlias,
+                                        expose: expose,
+                                        exposeModule: loadFactory ? moduleOrFactory : undefined,
+                                        exposeModuleFactory: loadFactory ? undefined : moduleOrFactory,
+                                        remote: remote,
+                                        options: moduleOptions,
+                                        moduleInstance: module,
+                                        origin: host
+                                    })
+                                ];
+                            case 4:
+                                moduleWrapper = _state.sent();
+                                _this.setIdToRemoteMap(id, remoteMatchInfo);
+                                if (typeof moduleWrapper === 'function') {
+                                    return [
+                                        2,
+                                        moduleWrapper
+                                    ];
+                                }
+                                return [
+                                    2,
+                                    moduleOrFactory
+                                ];
+                            case 5:
+                                error = _state.sent();
+                                _ref2 = options || {
+                                    from: 'runtime'
+                                }, _ref_from = _ref2.from, from = _ref_from === void 0 ? 'runtime' : _ref_from;
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.errorLoadRemote.emit({
+                                        id: id,
+                                        error: error,
+                                        from: from,
+                                        lifecycle: 'onLoad',
+                                        origin: host
+                                    })
+                                ];
+                            case 6:
+                                failOver = _state.sent();
+                                if (!failOver) {
+                                    throw error;
+                                }
+                                return [
+                                    2,
+                                    failOver
+                                ];
+                            case 7:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "preloadRemote",
+            value: function preloadRemote(preloadOptions) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    var host, preloadOps;
+                    return _ts_generator._(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                host = _this.host;
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforePreloadRemote.emit({
+                                        preloadOps: preloadOptions,
+                                        options: host.options,
+                                        origin: host
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                preloadOps = formatPreloadArgs(host.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,
+                                                            host.snapshotHandler.loadRemoteSnapshotInfo(remote)
+                                                        ];
+                                                    case 1:
+                                                        _ref = _state.sent(), globalSnapshot = _ref.globalSnapshot, remoteSnapshot = _ref.remoteSnapshot;
+                                                        return [
+                                                            4,
+                                                            _this.hooks.lifecycle.generatePreloadAssets.emit({
+                                                                origin: host,
+                                                                preloadOptions: ops,
+                                                                remote: remote,
+                                                                remoteInfo: remoteInfo,
+                                                                globalSnapshot: globalSnapshot,
+                                                                remoteSnapshot: remoteSnapshot
+                                                            })
+                                                        ];
+                                                    case 2:
+                                                        assets = _state.sent();
+                                                        if (!assets) {
+                                                            return [
+                                                                2
+                                                            ];
+                                                        }
+                                                        preloadAssets(remoteInfo, host, assets);
+                                                        return [
+                                                            2
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(ops) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }()))
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "registerRemotes",
+            value: function registerRemotes(remotes, options) {
+                var _this = this;
+                var host = this.host;
+                remotes.forEach(function(remote) {
+                    _this.registerRemote(remote, host.options.remotes, {
+                        force: options == null ? void 0 : options.force
+                    });
+                });
+            }
+        },
+        {
+            key: "getRemoteModuleAndOptions",
+            value: function getRemoteModuleAndOptions(options) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    var host, id, loadRemoteArgs, error, idRes, remoteSplitInfo, rawRemote, remoteInfo, matchInfo, remote, expose, module, moduleOptions;
+                    return _ts_generator._(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                host = _this.host;
+                                id = options.id;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.beforeRequest.emit({
+                                        id: id,
+                                        options: host.options,
+                                        origin: host
+                                    })
+                                ];
+                            case 2:
+                                loadRemoteArgs = _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                return [
+                                    4,
+                                    _this.hooks.lifecycle.errorLoadRemote.emit({
+                                        id: id,
+                                        options: host.options,
+                                        origin: host,
+                                        from: 'runtime',
+                                        error: error,
+                                        lifecycle: 'beforeRequest'
+                                    })
+                                ];
+                            case 4:
+                                loadRemoteArgs = _state.sent();
+                                if (!loadRemoteArgs) {
+                                    throw error;
+                                }
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                idRes = loadRemoteArgs.id;
+                                remoteSplitInfo = matchRemoteWithNameAndExpose(host.options.remotes, idRes);
+                                assert(remoteSplitInfo, "\n        Unable to locate ".concat(idRes, " in ").concat(host.options.name, ". Potential reasons for failure include:\n\n        1. ").concat(idRes, " was not included in the 'remotes' parameter of ").concat(host.options.name || 'the host', ".\n\n        2. ").concat(idRes, " could not be found in the 'remotes' of ").concat(host.options.name, " with either 'name' or 'alias' attributes.\n        3. ").concat(idRes, " is not online, injected, or loaded.\n        4. ").concat(idRes, "  cannot be accessed on the expected.\n        5. The 'beforeRequest' hook was provided but did not return the correct 'remoteInfo' when attempting to load ").concat(idRes, ".\n      "));
+                                rawRemote = remoteSplitInfo.remote;
+                                remoteInfo = getRemoteInfo(rawRemote);
+                                return [
+                                    4,
+                                    host.sharedHandler.hooks.lifecycle.afterResolve.emit(_extends._({
+                                        id: idRes
+                                    }, remoteSplitInfo, {
+                                        options: host.options,
+                                        origin: host,
+                                        remoteInfo: remoteInfo
+                                    }))
+                                ];
+                            case 6:
+                                matchInfo = _state.sent();
+                                remote = matchInfo.remote, expose = matchInfo.expose;
+                                assert(remote && expose, "The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ".concat(idRes, "."));
+                                module = host.moduleCache.get(remote.name);
+                                moduleOptions = {
+                                    host: host,
+                                    remoteInfo: remoteInfo
+                                };
+                                if (!module) {
+                                    module = new Module(moduleOptions);
+                                    host.moduleCache.set(remote.name, module);
+                                }
+                                return [
+                                    2,
+                                    {
+                                        module: module,
+                                        moduleOptions: moduleOptions,
+                                        remoteMatchInfo: matchInfo
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "registerRemote",
+            value: function registerRemote(remote, targetRemotes, options) {
+                var host = this.host;
+                var normalizeRemote = function() {
+                    if (remote.alias) {
+                        var findEqual = targetRemotes.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"));
+                    }
+                    if ('entry' in remote) {
+                        if (isBrowserEnv() && !remote.entry.startsWith('http')) {
+                            remote.entry = new URL(remote.entry, window.location.origin).href;
+                        }
+                    }
+                    if (!remote.shareScope) {
+                        remote.shareScope = DEFAULT_SCOPE;
+                    }
+                    if (!remote.type) {
+                        remote.type = DEFAULT_REMOTE_TYPE;
+                    }
+                };
+                this.hooks.lifecycle.beforeRegisterRemote.emit({
+                    remote: remote,
+                    origin: host
+                });
+                var registeredRemote = targetRemotes.find(function(item) {
+                    return item.name === remote.name;
+                });
+                if (!registeredRemote) {
+                    normalizeRemote();
+                    targetRemotes.push(remote);
+                    this.hooks.lifecycle.registerRemote.emit({
+                        remote: remote,
+                        origin: host
+                    });
+                } else {
+                    var messages = [
+                        'The remote "'.concat(remote.name, '" is already registered.'),
+                        (options == null ? void 0 : options.force) ? 'Hope you have known that OVERRIDE it may have some unexpected errors' : 'If you want to merge the remote, you can set "force: true".'
+                    ];
+                    if (options == null ? void 0 : options.force) {
+                        this.removeRemote(registeredRemote);
+                        normalizeRemote();
+                        targetRemotes.push(remote);
+                        this.hooks.lifecycle.registerRemote.emit({
+                            remote: remote,
+                            origin: host
+                        });
+                    }
+                    warn$1(messages.join(' '));
+                }
+            }
+        },
+        {
+            key: "removeRemote",
+            value: function removeRemote(remote) {
+                try {
+                    var host = this.host;
+                    var name = remote.name;
+                    var remoteIndex = host.options.remotes.findIndex(function(item) {
+                        return item.name === name;
+                    });
+                    if (remoteIndex !== -1) {
+                        host.options.remotes.splice(remoteIndex, 1);
+                    }
+                    var loadedModule = host.moduleCache.get(remote.name);
+                    if (loadedModule) {
+                        var remoteInfo = loadedModule.remoteInfo;
+                        var key = remoteInfo.entryGlobalName;
+                        if (globalThis[key]) {
+                            var _Object_getOwnPropertyDescriptor;
+                            if ((_Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(globalThis, key)) == null ? void 0 : _Object_getOwnPropertyDescriptor.configurable) {
+                                delete globalThis[key];
+                            } else {
+                                globalThis[key] = undefined;
+                            }
+                        }
+                        var remoteEntryUniqueKey = getRemoteEntryUniqueKey(loadedModule.remoteInfo);
+                        if (globalLoading[remoteEntryUniqueKey]) {
+                            delete globalLoading[remoteEntryUniqueKey];
+                        }
+                        host.snapshotHandler.manifestCache.delete(remoteInfo.entry);
+                        var remoteInsId = remoteInfo.buildVersion ? composeKeyWithSeparator(remoteInfo.name, remoteInfo.buildVersion) : remoteInfo.name;
+                        var remoteInsIndex = globalThis.__FEDERATION__.__INSTANCES__.findIndex(function(ins) {
+                            if (remoteInfo.buildVersion) {
+                                return ins.options.id === remoteInsId;
+                            } else {
+                                return ins.name === remoteInsId;
+                            }
+                        });
+                        if (remoteInsIndex !== -1) {
+                            var remoteIns = globalThis.__FEDERATION__.__INSTANCES__[remoteInsIndex];
+                            remoteInsId = remoteIns.options.id || remoteInsId;
+                            var globalShareScopeMap = getGlobalShareScope();
+                            var isAllSharedNotUsed = true;
+                            var needDeleteKeys = [];
+                            Object.keys(globalShareScopeMap).forEach(function(instId) {
+                                var shareScopeMap = globalShareScopeMap[instId];
+                                shareScopeMap && Object.keys(shareScopeMap).forEach(function(shareScope) {
+                                    var shareScopeVal = shareScopeMap[shareScope];
+                                    shareScopeVal && Object.keys(shareScopeVal).forEach(function(shareName) {
+                                        var sharedPkgs = shareScopeVal[shareName];
+                                        sharedPkgs && Object.keys(sharedPkgs).forEach(function(shareVersion) {
+                                            var shared = sharedPkgs[shareVersion];
+                                            if (shared && (typeof shared === "undefined" ? "undefined" : _type_of._(shared)) === 'object' && shared.from === remoteInfo.name) {
+                                                if (shared.loaded || shared.loading) {
+                                                    shared.useIn = shared.useIn.filter(function(usedHostName) {
+                                                        return usedHostName !== remoteInfo.name;
+                                                    });
+                                                    if (shared.useIn.length) {
+                                                        isAllSharedNotUsed = false;
+                                                    } else {
+                                                        needDeleteKeys.push([
+                                                            instId,
+                                                            shareScope,
+                                                            shareName,
+                                                            shareVersion
+                                                        ]);
+                                                    }
+                                                } else {
+                                                    needDeleteKeys.push([
+                                                        instId,
+                                                        shareScope,
+                                                        shareName,
+                                                        shareVersion
+                                                    ]);
+                                                }
+                                            }
+                                        });
+                                    });
+                                });
+                            });
+                            if (isAllSharedNotUsed) {
+                                remoteIns.shareScopeMap = {};
+                                delete globalShareScopeMap[remoteInsId];
+                            }
+                            needDeleteKeys.forEach(function(param) {
+                                var _param = _sliced_to_array._(param, 4), insId = _param[0], shareScope = _param[1], shareName = _param[2], shareVersion = _param[3];
+                                var _globalShareScopeMap_insId_shareScope_shareName, _globalShareScopeMap_insId_shareScope, _globalShareScopeMap_insId;
+                                (_globalShareScopeMap_insId = globalShareScopeMap[insId]) == null ? true : (_globalShareScopeMap_insId_shareScope = _globalShareScopeMap_insId[shareScope]) == null ? true : (_globalShareScopeMap_insId_shareScope_shareName = _globalShareScopeMap_insId_shareScope[shareName]) == null ? true : delete _globalShareScopeMap_insId_shareScope_shareName[shareVersion];
+                            });
+                            globalThis.__FEDERATION__.__INSTANCES__.splice(remoteInsIndex, 1);
+                        }
+                        var hostGlobalSnapshot = getGlobalRemoteInfo(remote, host).hostGlobalSnapshot;
+                        if (hostGlobalSnapshot) {
+                            var remoteKey = hostGlobalSnapshot && 'remotesInfo' in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, remote.name).key;
+                            if (remoteKey) {
+                                delete hostGlobalSnapshot.remotesInfo[remoteKey];
+                                if (Boolean(Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey])) {
+                                    delete Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey];
+                                }
+                            }
+                        }
+                        host.moduleCache.delete(remote.name);
+                    }
+                } catch (err) {
+                    console.log('removeRemote fail: ', err);
+                }
+            }
+        }
+    ]);
+    return RemoteHandler;
+}();
+var FederationHost = function() {
+    function FederationHost(userOptions) {
+        _class_call_check._(this, FederationHost);
+        this.hooks = new PluginSystem({
+            beforeInit: new SyncWaterfallHook('beforeInit'),
+            init: new SyncHook(),
+            beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
+            initContainer: new AsyncWaterfallHook('initContainer')
+        });
+        this.version = "0.5.1";
+        this.moduleCache = new Map();
+        this.loaderHook = new PluginSystem({
+            getModuleInfo: new SyncHook(),
+            createScript: new SyncHook(),
+            createLink: new SyncHook(),
+            fetch: new AsyncHook()
+        });
+        var defaultOptions = {
+            id: getBuilderId(),
+            name: userOptions.name,
+            plugins: [
+                snapshotPlugin(),
+                generatePreloadAssetsPlugin()
+            ],
+            remotes: [],
+            shared: {},
+            inBrowser: isBrowserEnv()
+        };
+        this.name = userOptions.name;
+        this.options = defaultOptions;
+        this.snapshotHandler = new SnapshotHandler(this);
+        this.sharedHandler = new SharedHandler(this);
+        this.remoteHandler = new RemoteHandler(this);
+        this.shareScopeMap = this.sharedHandler.shareScopeMap;
+        this.registerPlugins(_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: function loadShare(pkgName, extraOptions) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    return _ts_generator._(this, function(_state) {
+                        return [
+                            2,
+                            _this.sharedHandler.loadShare(pkgName, extraOptions)
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "loadShareSync",
+            value: function loadShareSync(pkgName, extraOptions) {
+                return this.sharedHandler.loadShareSync(pkgName, extraOptions);
+            }
+        },
+        {
+            key: "initializeSharing",
+            value: function initializeSharing() {
+                var shareScopeName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_SCOPE, strategy = arguments.length > 1 ? arguments[1] : void 0;
+                return this.sharedHandler.initializeSharing(shareScopeName, strategy);
+            }
+        },
+        {
+            key: "initRawContainer",
+            value: function initRawContainer(name, url, container) {
+                var remoteInfo = getRemoteInfo({
+                    name: name,
+                    entry: url
+                });
+                var module = new Module({
+                    host: this,
+                    remoteInfo: remoteInfo
+                });
+                module.remoteEntryExports = container;
+                this.moduleCache.set(name, module);
+                return module;
+            }
+        },
+        {
+            key: "loadRemote",
+            value: function loadRemote(id, options) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    return _ts_generator._(this, function(_state) {
+                        return [
+                            2,
+                            _this.remoteHandler.loadRemote(id, options)
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "preloadRemote",
+            value: function preloadRemote(preloadOptions) {
+                var _this = this;
+                return _async_to_generator._(function() {
+                    return _ts_generator._(this, function(_state) {
+                        return [
+                            2,
+                            _this.remoteHandler.preloadRemote(preloadOptions)
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "initShareScopeMap",
+            value: function initShareScopeMap(scopeName, shareScope) {
+                var extraOptions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+                this.sharedHandler.initShareScopeMap(scopeName, shareScope, extraOptions);
+            }
+        },
+        {
+            key: "formatOptions",
+            value: function formatOptions(globalOptions, userOptions) {
+                var shared = formatShareConfigs(globalOptions, userOptions).shared;
+                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 remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
+                var _this_sharedHandler_registerShared = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes), handledShared = _this_sharedHandler_registerShared.shared;
+                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: handledShared
+                });
+                this.hooks.lifecycle.init.emit({
+                    origin: this,
+                    options: optionsRes
+                });
+                return optionsRes;
+            }
+        },
+        {
+            key: "registerPlugins",
+            value: function registerPlugins(plugins) {
+                var pluginRes = registerPlugins$1(plugins, [
+                    this.hooks,
+                    this.remoteHandler.hooks,
+                    this.sharedHandler.hooks,
+                    this.snapshotHandler.hooks,
+                    this.loaderHook
+                ]);
+                this.options.plugins = this.options.plugins.reduce(function(res, plugin) {
+                    if (!plugin) return res;
+                    if (res && !res.find(function(item) {
+                        return item.name === plugin.name;
+                    })) {
+                        res.push(plugin);
+                    }
+                    return res;
+                }, pluginRes || []);
+            }
+        },
+        {
+            key: "registerRemotes",
+            value: function registerRemotes(remotes, options) {
+                return this.remoteHandler.registerRemotes(remotes, options);
+            }
+        }
+    ]);
+    return FederationHost;
+}();
+var FederationInstance = null;
+function init(options) {
+    var instance = getGlobalFederationInstance(options.name, options.version);
+    if (!instance) {
+        var FederationConstructor = getGlobalFederationConstructor() || FederationHost;
+        FederationInstance = new FederationConstructor(options);
+        setGlobalFederationInstance(FederationInstance);
+        return FederationInstance;
+    } else {
+        instance.initOptions(options);
+        if (!FederationInstance) {
+            FederationInstance = instance;
+        }
+        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');
+    var loadRemote1 = FederationInstance.loadRemote;
+    return loadRemote1.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');
+    var loadShare1 = FederationInstance.loadShare;
+    return loadShare1.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');
+    var loadShareSync1 = FederationInstance.loadShareSync;
+    return loadShareSync1.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');
+    return FederationInstance.preloadRemote.apply(FederationInstance, args);
+}
+function registerRemotes() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    assert(FederationInstance, 'Please call init first');
+    return FederationInstance.registerRemotes.apply(FederationInstance, args);
+}
+function registerPlugins() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    assert(FederationInstance, 'Please call init first');
+    return FederationInstance.registerPlugins.apply(FederationInstance, args);
+}
+function getInstance() {
+    return FederationInstance;
+}
+setGlobalFederationConstructor(FederationHost);
+
+var runtime = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  FederationHost: FederationHost,
+  getInstance: getInstance,
+  getRemoteEntry: getRemoteEntry,
+  getRemoteInfo: getRemoteInfo,
+  init: init,
+  loadRemote: loadRemote,
+  loadShare: loadShare,
+  loadShareSync: loadShareSync,
+  preloadRemote: preloadRemote,
+  registerPlugins: registerPlugins,
+  registerRemotes: registerRemotes,
+  registerGlobalPlugins: registerGlobalPlugins,
+  loadScript: loadScript,
+  loadScriptNode: loadScriptNode
+});
+
+function attachShareScopeMap(webpackRequire) {
+    if (!webpackRequire.S || webpackRequire.federation.hasAttachShareScopeMap || !webpackRequire.federation.instance || !webpackRequire.federation.instance.shareScopeMap) {
+        return;
+    }
+    webpackRequire.S = webpackRequire.federation.instance.shareScopeMap;
+    webpackRequire.federation.hasAttachShareScopeMap = true;
+}
+
+var FEDERATION_SUPPORTED_TYPES = [
+    'script'
+];
+
+function remotes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, idToExternalAndNameMapping = options.idToExternalAndNameMapping, webpackRequire = options.webpackRequire, idToRemoteMap = options.idToRemoteMap;
+    attachShareScopeMap(webpackRequire);
+    if (webpackRequire.o(chunkMapping, chunkId)) {
+        chunkMapping[chunkId].forEach(function(id) {
+            var getScope = webpackRequire.R;
+            if (!getScope) {
+                getScope = [];
+            }
+            var data = idToExternalAndNameMapping[id];
+            var remoteInfos = idToRemoteMap[id];
+            if (getScope.indexOf(data) >= 0) {
+                return;
+            }
+            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();
+            };
+            var onInitialized = function(_, external, first) {
+                return handleFunction(external.get, data[1], getScope, 0, onFactory, first);
+            };
+            var onFactory = function(factory) {
+                data.p = 1;
+                webpackRequire.m[id] = function(module) {
+                    module.exports = factory();
+                };
+            };
+            var onRemoteLoaded = function() {
+                try {
+                    var remoteName = decodeName(remoteInfos[0].name, ENCODE_NAME_PREFIX);
+                    var remoteModuleName = remoteName + data[1].slice(1);
+                    return webpackRequire.federation.instance.loadRemote(remoteModuleName, {
+                        loadFactory: false,
+                        from: 'build'
+                    });
+                } catch (error) {
+                    onError(error);
+                }
+            };
+            var useRuntimeLoad = remoteInfos.length === 1 && FEDERATION_SUPPORTED_TYPES.includes(remoteInfos[0].externalType) && remoteInfos[0].name;
+            if (useRuntimeLoad) {
+                handleFunction(onRemoteLoaded, data[2], 0, 0, onFactory, 1);
+            } else {
+                handleFunction(webpackRequire, data[2], 0, 0, onExternal, 1);
+            }
+        });
+    }
+}
+
+function consumes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, installedModules = options.installedModules, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    attachShareScopeMap(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('Federation instance not found!');
+                }
+                var _moduleToHandlerMapping_id = moduleToHandlerMapping[id], shareKey = _moduleToHandlerMapping_id.shareKey, getter = _moduleToHandlerMapping_id.getter, shareInfo = _moduleToHandlerMapping_id.shareInfo;
+                var promise = federationInstance.loadShare(shareKey, {
+                    customShareInfo: shareInfo
+                }).then(function(factory) {
+                    if (factory === false) {
+                        return getter();
+                    }
+                    return factory;
+                });
+                if (promise.then) {
+                    promises.push(installedModules[id] = promise.then(onFactory).catch(onError));
+                } else {
+                    onFactory(promise);
+                }
+            } catch (e) {
+                onError(e);
+            }
+        });
+    }
+}
+
+function initializeSharing(param) {
+    var shareScopeName = param.shareScopeName, webpackRequire = param.webpackRequire, initPromises = param.initPromises, initTokens = param.initTokens, initScope = param.initScope;
+    if (!initScope) initScope = [];
+    var initToken = initTokens[shareScopeName];
+    if (!initToken) initToken = initTokens[shareScopeName] = {};
+    if (initScope.indexOf(initToken) >= 0) return;
+    initScope.push(initToken);
+    var promise = initPromises[shareScopeName];
+    if (promise) return promise;
+    var warn = function(msg) {
+        return typeof console !== 'undefined' && console.warn && console.warn(msg);
+    };
+    var initExternal = function(id) {
+        var handleError = function(err) {
+            return warn('Initialization of sharing external failed: ' + err);
+        };
+        try {
+            var module = webpackRequire(id);
+            if (!module) return;
+            var initFn = function(module) {
+                return module && module.init && module.init(webpackRequire.S[shareScopeName], initScope);
+            };
+            if (module.then) return promises.push(module.then(initFn, handleError));
+            var initResult = initFn(module);
+            if (initResult && typeof initResult !== 'boolean' && initResult.then) return promises.push(initResult['catch'](handleError));
+        } catch (err) {
+            handleError(err);
+        }
+    };
+    var promises = webpackRequire.federation.instance.initializeSharing(shareScopeName);
+    attachShareScopeMap(webpackRequire);
+    var bundlerRuntimeRemotesOptions = webpackRequire.federation.bundlerRuntimeOptions.remotes;
+    if (bundlerRuntimeRemotesOptions) {
+        Object.keys(bundlerRuntimeRemotesOptions.idToRemoteMap).forEach(function(moduleId) {
+            var info = bundlerRuntimeRemotesOptions.idToRemoteMap[moduleId];
+            var externalModuleId = bundlerRuntimeRemotesOptions.idToExternalAndNameMapping[moduleId][2];
+            if (info.length > 1) {
+                initExternal(externalModuleId);
+            } else if (info.length === 1) {
+                var remoteInfo = info[0];
+                if (!FEDERATION_SUPPORTED_TYPES.includes(remoteInfo.externalType)) {
+                    initExternal(externalModuleId);
+                }
+            }
+        });
+    }
+    if (!promises.length) {
+        return initPromises[shareScopeName] = true;
+    }
+    return initPromises[shareScopeName] = Promise.all(promises).then(function() {
+        return initPromises[shareScopeName] = true;
+    });
+}
+
+function handleInitialConsumes(options) {
+    var moduleId = options.moduleId, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    var federationInstance = webpackRequire.federation.instance;
+    if (!federationInstance) {
+        throw new Error('Federation instance not found!');
+    }
+    var _moduleToHandlerMapping_moduleId = moduleToHandlerMapping[moduleId], shareKey = _moduleToHandlerMapping_moduleId.shareKey, shareInfo = _moduleToHandlerMapping_moduleId.shareInfo;
+    try {
+        return federationInstance.loadShareSync(shareKey, {
+            customShareInfo: shareInfo
+        });
+    } catch (err) {
+        console.error('loadShareSync failed! The function should not be called unless you set "eager:true". If you do not set it, and encounter this issue, you can check whether an async boundary is implemented.');
+        console.error('The original error message is as follows: ');
+        throw err;
+    }
+}
+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) {
+            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();
+        };
+    });
+}
+
+function initContainerEntry(options) {
+    var webpackRequire = options.webpackRequire, shareScope = options.shareScope, initScope = options.initScope, shareScopeKey = options.shareScopeKey, remoteEntryInitOptions = options.remoteEntryInitOptions;
+    if (!webpackRequire.S) return;
+    if (!webpackRequire.federation || !webpackRequire.federation.instance || !webpackRequire.federation.initOptions) return;
+    var federationInstance = webpackRequire.federation.instance;
+    var name = shareScopeKey || 'default';
+    federationInstance.initOptions(_object_spread._({
+        name: webpackRequire.federation.initOptions.name,
+        remotes: []
+    }, remoteEntryInitOptions));
+    federationInstance.initShareScopeMap(name, shareScope, {
+        hostShareScopeMap: (remoteEntryInitOptions === null || remoteEntryInitOptions === void 0 ? void 0 : remoteEntryInitOptions.shareScopeMap) || {}
+    });
+    if (webpackRequire.federation.attachShareScopeMap) {
+        webpackRequire.federation.attachShareScopeMap(webpackRequire);
+    }
+    return webpackRequire.I(name, initScope);
+}
+
+var federation = {
+    runtime: runtime,
+    instance: undefined,
+    initOptions: undefined,
+    bundlerRuntime: {
+        remotes: remotes,
+        consumes: consumes,
+        I: initializeSharing,
+        S: {},
+        installInitialConsumes: installInitialConsumes,
+        initContainerEntry: initContainerEntry
+    },
+    attachShareScopeMap: attachShareScopeMap,
+    bundlerRuntimeOptions: {}
+};
+
+module.exports = federation;