@module-federation/runtime 1.0.0-canary.1

package/index.esm.js

@@ -0,0 +1,1917 @@
+import { i as isStaticResourcesEqual, s as safeWrapper, g as getGlobalHostPlugins, _ as _extends, D as DEFAULT_REMOTE_TYPE, a as DEFAULT_SCOPE, b as globalLoading, c as getRemoteEntryExports, d as assert, e as safeToString$1, G as Global, f as getFMId, h as isObject, j as error, w as warn, k as isPlainObject, l as isRemoteInfoWithEntry, m as isPureRemoteEntry, n as getGlobalShare, o as getInfoWithoutType, p as getPreloaded, q as setPreloaded, r as getGlobalSnapshotInfoByModuleInfo, t as setGlobalSnapshotInfoByModuleInfo, u as getGlobalSnapshot, v as addUniqueItem, x as formatShareConfigs, y as isBrowserEnv$1, z as getGlobalShareScope, A as _object_without_properties_loose, B as getBuilderId, C as setGlobalFederationConstructor, E as getGlobalFederationInstance, F as getGlobalFederationConstructor, H as setGlobalFederationInstance } from './share.esm.js';
+export { I as registerGlobalPlugins } from './share.esm.js';
+
+function getResourceUrl(module, sourceUrl) {
+    if ('getPublicPath' in module) {
+        const publicPath = new Function(module.getPublicPath)();
+        return `${publicPath}${sourceUrl}`;
+    } else if ('publicPath' in module) {
+        return `${module.publicPath}${sourceUrl}`;
+    } else {
+        console.warn('Cannot get resource URL. If in debug mode, please ignore.', module, sourceUrl);
+        return '';
+    }
+}
+// id: pkgName(@federation/app1) + expose(button) = @federation/app1/button
+// id: alias(app1) + expose(button) = app1/button
+// id: alias(app1/utils) + expose(loadash/sort) = app1/utils/loadash/sort
+function matchRemoteWithNameAndExpose(remotes, id) {
+    for (const remote of remotes){
+        // match pkgName
+        const matchNameSuccess = id.startsWith(remote.name);
+        let expose = id.replace(remote.name, '');
+        if (matchNameSuccess) {
+            if (expose.startsWith('/')) {
+                const pkgNameOrAlias = remote.name;
+                expose = `.${expose}`;
+                return {
+                    pkgNameOrAlias,
+                    expose,
+                    remote
+                };
+            } else if (expose === '') {
+                return {
+                    pkgNameOrAlias: remote.name,
+                    expose: '.',
+                    remote
+                };
+            }
+        }
+        // match alias
+        const matchAliasSuccess = remote.alias && id.startsWith(remote.alias);
+        let exposeWithAlias = remote.alias && id.replace(remote.alias, '');
+        if (remote.alias && matchAliasSuccess) {
+            if (exposeWithAlias && exposeWithAlias.startsWith('/')) {
+                const pkgNameOrAlias = remote.alias;
+                exposeWithAlias = `.${exposeWithAlias}`;
+                return {
+                    pkgNameOrAlias,
+                    expose: exposeWithAlias,
+                    remote
+                };
+            } else if (exposeWithAlias === '') {
+                return {
+                    pkgNameOrAlias: remote.alias,
+                    expose: '.',
+                    remote
+                };
+            }
+        }
+    }
+    return;
+}
+function matchRemote(remotes, nameOrAlias) {
+    for (const remote of remotes){
+        const matchNameSuccess = nameOrAlias === remote.name;
+        if (matchNameSuccess) {
+            return remote;
+        }
+        const matchAliasSuccess = remote.alias && nameOrAlias === remote.alias;
+        if (matchAliasSuccess) {
+            return remote;
+        }
+    }
+    return;
+}
+
+function createScript(url, cb, attrs, createScriptHook) {
+    // get the existing script element by src
+    let script = null;
+    let needAttach = true;
+    const scripts = document.getElementsByTagName('script');
+    for(let i = 0; i < scripts.length; i++){
+        const s = scripts[i];
+        const scriptSrc = s.getAttribute('src');
+        if (scriptSrc && isStaticResourcesEqual(scriptSrc, url)) {
+            script = s;
+            needAttach = false;
+            break;
+        }
+    }
+    if (!script) {
+        script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = url;
+        if (createScriptHook) {
+            const createScriptRes = createScriptHook(url);
+            if (createScriptRes instanceof HTMLScriptElement) {
+                script = createScriptRes;
+            }
+        }
+    }
+    if (attrs) {
+        Object.keys(attrs).forEach((name)=>{
+            if (script) {
+                if (name === 'async' || name === 'defer') {
+                    script[name] = attrs[name];
+                } else {
+                    script.setAttribute(name, attrs[name]);
+                }
+            }
+        });
+    }
+    const onScriptComplete = (prev, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    event)=>{
+        // avoid memory leaks in IE.
+        if (script) {
+            script.onerror = null;
+            script.onload = null;
+            safeWrapper(()=>{
+                (script == null ? void 0 : script.parentNode) && script.parentNode.removeChild(script);
+            });
+            if (prev) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const res = prev(event);
+                cb();
+                return res;
+            }
+        }
+        cb();
+    };
+    script.onerror = onScriptComplete.bind(null, script.onerror);
+    script.onload = onScriptComplete.bind(null, script.onload);
+    return {
+        script,
+        needAttach
+    };
+}
+function loadScript(url, info) {
+    const { attrs, createScriptHook } = info;
+    return new Promise((resolve, _reject)=>{
+        const { script, needAttach } = createScript(url, resolve, attrs, createScriptHook);
+        needAttach && document.getElementsByTagName('head')[0].appendChild(script);
+    });
+}
+
+function registerPlugins(plugins, hookInstances) {
+    const globalPlugins = getGlobalHostPlugins();
+    // Register global plugins
+    if (globalPlugins.length > 0) {
+        globalPlugins.forEach((plugin)=>{
+            if (plugins == null ? void 0 : plugins.find((item)=>item.name !== plugin.name)) {
+                plugins.push(plugin);
+            }
+        });
+    }
+    if (plugins && plugins.length > 0) {
+        plugins.forEach((plugin)=>{
+            hookInstances.forEach((hookInstance)=>{
+                hookInstance.usePlugin(plugin);
+            });
+        });
+    }
+}
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var MANIFEST_EXT = ".json";
+var BROWSER_LOG_KEY = "''";
+var BROWSER_LOG_VALUE = "1";
+var NameTransformSymbol = {
+    AT: "@",
+    HYPHEN: "-",
+    SLASH: "/"
+};
+var _obj;
+var NameTransformMap = (_obj = {}, _define_property$2(_obj, NameTransformSymbol.AT, "scope_"), _define_property$2(_obj, NameTransformSymbol.HYPHEN, "_"), _define_property$2(_obj, NameTransformSymbol.SLASH, "__"), _obj);
+var _obj1;
+(_obj1 = {}, _define_property$2(_obj1, NameTransformMap[NameTransformSymbol.AT], NameTransformSymbol.AT), _define_property$2(_obj1, NameTransformMap[NameTransformSymbol.HYPHEN], NameTransformSymbol.HYPHEN), _define_property$2(_obj1, NameTransformMap[NameTransformSymbol.SLASH], NameTransformSymbol.SLASH), _obj1);
+var SEPARATOR = ":";
+function isBrowserEnv() {
+    return typeof window !== "undefined";
+}
+function isDebugMode() {
+    if (typeof process !== "undefined" && process.env && process.env["''"]) {
+        return Boolean(process.env["''"]);
+    }
+    return Boolean('');
+}
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!_instanceof(instance, Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function safeToString(info) {
+    try {
+        return JSON.stringify(info, null, 2);
+    } catch (e) {
+        return "";
+    }
+}
+var DEBUG_LOG = "[ FEDERATION DEBUG ]";
+var Logger = /*#__PURE__*/ function() {
+    function Logger(identifier) {
+        _class_call_check(this, Logger);
+        _define_property$1(this, "enable", false);
+        _define_property$1(this, "identifier", void 0);
+        this.identifier = identifier || DEBUG_LOG;
+        if (isBrowserEnv() && localStorage.getItem(BROWSER_LOG_KEY) === BROWSER_LOG_VALUE) {
+            this.enable = true;
+        } else if (isDebugMode()) {
+            this.enable = true;
+        }
+    }
+    _create_class(Logger, [
+        {
+            key: "info",
+            value: function info(msg, info) {
+                if (this.enable) {
+                    var argsToString = safeToString(info) || "";
+                    if (isBrowserEnv()) {
+                        console.info("%c ".concat(this.identifier, ": ").concat(msg, " ").concat(argsToString), "color:#3300CC");
+                    } else {
+                        console.info("\x1b[34m%s", "".concat(this.identifier, ": ").concat(msg, " ").concat(argsToString ? "\n".concat(argsToString) : ""));
+                    }
+                }
+            }
+        },
+        {
+            key: "logOriginalInfo",
+            value: function logOriginalInfo() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                if (this.enable) {
+                    if (isBrowserEnv()) {
+                        var _console;
+                        console.info("%c ".concat(this.identifier, ": OriginalInfo"), "color:#3300CC");
+                        (_console = console).log.apply(_console, _to_consumable_array(args));
+                    } else {
+                        var _console1;
+                        console.info("%c ".concat(this.identifier, ": OriginalInfo"), "color:#3300CC");
+                        (_console1 = console).log.apply(_console1, _to_consumable_array(args));
+                    }
+                }
+            }
+        }
+    ]);
+    return Logger;
+}();
+new Logger();
+var composeKeyWithSeparator = function composeKeyWithSeparator() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    if (!args.length) {
+        return "";
+    }
+    return args.reduce(function(sum, cur) {
+        if (!cur) {
+            return sum;
+        }
+        if (!sum) {
+            return cur;
+        }
+        return "".concat(sum).concat(SEPARATOR).concat(cur);
+    }, "");
+};
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+var simpleJoinRemoteEntry = function simpleJoinRemoteEntry(rPath, rName) {
+    if (!rPath) {
+        return rName;
+    }
+    var transformPath = function transformPath(str) {
+        if (str === ".") {
+            return "";
+        }
+        if (str.startsWith("./")) {
+            return str.replace("./", "");
+        }
+        if (str.startsWith("/")) {
+            var strWithoutSlash = str.slice(1);
+            if (strWithoutSlash.endsWith("/")) {
+                return strWithoutSlash.slice(0, -1);
+            }
+            return strWithoutSlash;
+        }
+        return str;
+    };
+    var transformedPath = transformPath(rPath);
+    if (!transformedPath) {
+        return rName;
+    }
+    if (transformedPath.endsWith("/")) {
+        return "".concat(transformedPath).concat(rName);
+    }
+    return "".concat(transformedPath, "/").concat(rName);
+};
+// 优先级：overrides > remotes
+// eslint-disable-next-line max-lines-per-function
+function generateSnapshotFromManifest(manifest) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var _options_remotes = options.remotes, remotes = _options_remotes === void 0 ? {} : _options_remotes, _options_overrides = options.overrides, overrides = _options_overrides === void 0 ? {} : _options_overrides, version = options.version;
+    var remoteSnapshot;
+    var getPublicPath = function getPublicPath() {
+        if ("publicPath" in manifest.metaData) {
+            return manifest.metaData.publicPath;
+        } else {
+            return manifest.metaData.getPublicPath;
+        }
+    };
+    var overridesKeys = Object.keys(overrides);
+    var remotesInfo = {};
+    // If remotes are not passed, only the remotes in the manifest will be read
+    if (!Object.keys(remotes).length) {
+        var _manifest_remotes;
+        remotesInfo = ((_manifest_remotes = manifest.remotes) === null || _manifest_remotes === void 0 ? void 0 : _manifest_remotes.reduce(function(res, next) {
+            var matchedVersion;
+            var name = next.federationContainerName;
+            // overrides has hight priority
+            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;
+        }, {})) || {};
+    }
+    // If remotes (deploy scenario) are specified, you need to traverse it again
+    Object.keys(remotes).forEach(function(key) {
+        return remotesInfo[key] = {
+            // overrides will override dependencies
+            matchedVersion: overridesKeys.includes(key) ? overrides[key] : remotes[key]
+        };
+    });
+    var _manifest_metaData = manifest.metaData, _manifest_metaData_remoteEntry = _manifest_metaData.remoteEntry, remoteEntryPath = _manifest_metaData_remoteEntry.path, remoteEntryName = _manifest_metaData_remoteEntry.name, remoteEntryType = _manifest_metaData_remoteEntry.type, remoteTypes = _manifest_metaData.types, buildVersion = _manifest_metaData.buildInfo.buildVersion, globalName = _manifest_metaData.globalName;
+    var exposes = manifest.exposes;
+    var basicRemoteSnapshot = {
+        version: version ? version : "",
+        buildVersion: buildVersion,
+        globalName: globalName,
+        remoteEntry: simpleJoinRemoteEntry(remoteEntryPath, remoteEntryName),
+        remoteEntryType: remoteEntryType,
+        remoteTypes: simpleJoinRemoteEntry(remoteTypes.path, remoteTypes.name),
+        remotesInfo: remotesInfo,
+        shared: manifest === null || manifest === void 0 ? void 0 : manifest.shared.map(function(item) {
+            return {
+                assets: item.assets,
+                sharedName: item.name
+            };
+        }),
+        modules: exposes === null || exposes === void 0 ? void 0 : exposes.map(function(expose) {
+            return {
+                moduleName: expose.name,
+                modulePath: expose.path,
+                assets: expose.assets
+            };
+        })
+    };
+    if ("publicPath" in manifest.metaData) {
+        remoteSnapshot = _object_spread_props(_object_spread({}, basicRemoteSnapshot), {
+            publicPath: getPublicPath()
+        });
+    } else {
+        remoteSnapshot = _object_spread_props(_object_spread({}, basicRemoteSnapshot), {
+            getPublicPath: getPublicPath()
+        });
+    }
+    return remoteSnapshot;
+}
+function isManifestProvider(moduleInfo) {
+    if ("remoteEntry" in moduleInfo && moduleInfo.remoteEntry.endsWith(MANIFEST_EXT)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+async function loadEsmEntry({ entry, remoteEntryExports }) {
+    return new Promise((resolve, reject)=>{
+        try {
+            if (!remoteEntryExports) {
+                // eslint-disable-next-line no-eval
+                new Function('resolve', `import("${entry}").then((res)=>{resolve(res);}, (error)=> reject(error))`)(resolve);
+            } else {
+                resolve(remoteEntryExports);
+            }
+        } catch (e) {
+            reject(e);
+        }
+    });
+}
+async function loadEntryScript({ name, globalName, entry, createScriptHook }) {
+    const { entryExports: remoteEntryExports } = getRemoteEntryExports(name, globalName);
+    if (remoteEntryExports) {
+        return remoteEntryExports;
+    }
+    return loadScript(entry, {
+        attrs: {},
+        createScriptHook
+    }).then(()=>{
+        const { remoteEntryKey, entryExports } = getRemoteEntryExports(name, globalName);
+        assert(entryExports, `
+      Cannot use the ${name}'s '${entry}' URL with ${remoteEntryKey}'s globalName to get remoteEntry exports.
+      The following reasons may be causing the problem:\n
+      1. '${entry}' is not the correct URL, or the remoteEntry resource or name is incorrect.\n
+      2. Unable to use ${remoteEntryKey} to get remoteEntry exports in the window object.
+    `);
+        return entryExports;
+    });
+}
+async function getRemoteEntry({ remoteEntryExports, remoteInfo, createScriptHook }) {
+    const { entry, name, type, entryGlobalName } = remoteInfo;
+    const uniqueKey = composeKeyWithSeparator(name, entry);
+    if (remoteEntryExports) {
+        return remoteEntryExports;
+    }
+    if (!globalLoading[uniqueKey]) {
+        if (type === 'esm') {
+            globalLoading[uniqueKey] = loadEsmEntry({
+                entry,
+                remoteEntryExports
+            });
+        } else {
+            globalLoading[uniqueKey] = loadEntryScript({
+                name,
+                globalName: entryGlobalName,
+                entry,
+                createScriptHook
+            });
+        }
+    }
+    return globalLoading[uniqueKey];
+}
+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
+    });
+}
+
+let Module = class Module {
+    async getEntry() {
+        if (this.remoteEntryExports) {
+            return this.remoteEntryExports;
+        }
+        // Get remoteEntry.js
+        const remoteEntryExports = await getRemoteEntry({
+            remoteInfo: this.remoteInfo,
+            remoteEntryExports: this.remoteEntryExports,
+            createScriptHook: (url)=>{
+                const res = this.loaderHook.lifecycle.createScript.emit({
+                    url
+                });
+                if (res instanceof HTMLScriptElement) {
+                    return res;
+                }
+                return;
+            }
+        });
+        assert(remoteEntryExports, `remoteEntryExports is undefined \n ${safeToString$1(this.remoteInfo)}`);
+        this.remoteEntryExports = remoteEntryExports;
+        return this.remoteEntryExports;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async get(expose, options) {
+        const { loadFactory = true } = options || {
+            loadFactory: true
+        };
+        // Get remoteEntry.js
+        const remoteEntryExports = await this.getEntry();
+        if (!this.inited) {
+            const globalShareScope = Global.__FEDERATION__.__SHARE__;
+            const remoteShareScope = this.remoteInfo.shareScope || 'default';
+            if (!globalShareScope[remoteShareScope]) {
+                globalShareScope[remoteShareScope] = {};
+            }
+            const shareScope = globalShareScope[remoteShareScope];
+            // TODO: compat logic , it could be moved after providing startup hooks
+            const remoteEntryInitOptions = {
+                version: this.remoteInfo.version || '',
+                // @ts-ignore it will be passed by startup hooks
+                region: this.hostInfo.region
+            };
+            remoteEntryExports.init(shareScope, [], remoteEntryInitOptions);
+            const federationInstance = Global.__FEDERATION__.__INSTANCES__.find((i)=>i.options.id === composeKeyWithSeparator(this.remoteInfo.name, this.remoteInfo.buildVersion));
+            if (federationInstance) {
+                federationInstance.initOptions(_extends({}, remoteEntryInitOptions, {
+                    remotes: [],
+                    name: this.remoteInfo.name
+                }));
+            }
+        }
+        this.lib = remoteEntryExports;
+        this.inited = true;
+        // get exposeGetter
+        const moduleFactory = await remoteEntryExports.get(expose);
+        assert(moduleFactory, `${getFMId(this.remoteInfo)} remote don't export ${expose}.`);
+        if (!loadFactory) {
+            return moduleFactory;
+        }
+        const exposeContent = await moduleFactory();
+        return exposeContent;
+    }
+    // loading: Record<string, undefined | Promise<RemoteEntryExports | void>> = {};
+    constructor({ hostInfo, remoteInfo, shared, loaderHook }){
+        this.inited = false;
+        this.shared = {};
+        this.lib = undefined;
+        this.hostInfo = hostInfo;
+        this.remoteInfo = remoteInfo;
+        this.shared = shared;
+        this.loaderHook = loaderHook;
+    }
+};
+
+class SyncHook {
+    on(fn) {
+        if (typeof fn === 'function') {
+            this.listeners.add(fn);
+        }
+    }
+    once(fn) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        this.on(function wrapper(...args) {
+            self.remove(wrapper);
+            // eslint-disable-next-line prefer-spread
+            return fn.apply(null, args);
+        });
+    }
+    emit(...data) {
+        let result;
+        if (this.listeners.size > 0) {
+            // eslint-disable-next-line prefer-spread
+            this.listeners.forEach((fn)=>{
+                result = fn(...data);
+            });
+        }
+        return result;
+    }
+    remove(fn) {
+        this.listeners.delete(fn);
+    }
+    removeAll() {
+        this.listeners.clear();
+    }
+    constructor(type){
+        this.type = '';
+        this.listeners = new Set();
+        if (type) {
+            this.type = type;
+        }
+    }
+}
+
+class AsyncHook extends SyncHook {
+    emit(...data) {
+        let result;
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const call = (prev)=>{
+                if (prev === false) {
+                    return false; // Abort process
+                } else if (i < ls.length) {
+                    return Promise.resolve(ls[i++].apply(null, data)).then(call);
+                } else {
+                    return prev;
+                }
+            };
+            result = call();
+        }
+        return Promise.resolve(result);
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function checkReturnData(originData, returnData) {
+    if (!isObject(returnData)) {
+        return false;
+    }
+    if (originData !== returnData) {
+        // eslint-disable-next-line no-restricted-syntax
+        for(const key in originData){
+            if (!(key in returnData)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+class SyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!isObject(data)) {
+            error(`"${this.type}" hook response data must be an object.`);
+        }
+        for (const fn of this.listeners){
+            try {
+                const tempData = fn(data);
+                if (checkReturnData(data, tempData)) {
+                    data = tempData;
+                } else {
+                    this.onerror(`The "${this.type}" type has a plugin return value error.`);
+                    break;
+                }
+            } catch (e) {
+                warn(e);
+                this.onerror(e);
+            }
+        }
+        return data;
+    }
+    constructor(type){
+        super();
+        this.onerror = error;
+        this.type = type;
+    }
+}
+
+class AsyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!isObject(data)) {
+            error(`"${this.type}" hook response data must be an object.`);
+        }
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const processError = (e)=>{
+                warn(e);
+                this.onerror(e);
+                return data;
+            };
+            const call = (prevData)=>{
+                if (checkReturnData(data, prevData)) {
+                    data = prevData;
+                    if (i < ls.length) {
+                        try {
+                            return Promise.resolve(ls[i++](data)).then(call, processError);
+                        } catch (e) {
+                            return processError(e);
+                        }
+                    }
+                } else {
+                    this.onerror(`The "${this.type}" type has a plugin return value error.`);
+                }
+                return data;
+            };
+            return Promise.resolve(call(data));
+        }
+        return Promise.resolve(data);
+    }
+    constructor(type){
+        super();
+        this.onerror = error;
+        this.type = type;
+    }
+}
+
+class PluginSystem {
+    usePlugin(plugin) {
+        assert(isPlainObject(plugin), 'Invalid plugin configuration.');
+        // The plugin name is required and must be unique
+        const pluginName = plugin.name;
+        assert(pluginName, 'Plugin must provide a name.');
+        if (!this.registerPlugins[pluginName]) {
+            this.registerPlugins[pluginName] = plugin;
+            Object.keys(this.lifecycle).forEach((key)=>{
+                const pluginLife = plugin[key];
+                if (pluginLife) {
+                    this.lifecycle[key].on(pluginLife);
+                }
+            });
+        }
+    }
+    removePlugin(pluginName) {
+        assert(pluginName, 'Must provide a name.');
+        const plugin = this.registerPlugins[pluginName];
+        assert(plugin, `plugin "${pluginName}" is not registered.`);
+        Object.keys(plugin).forEach((key)=>{
+            if (key !== 'name') {
+                this.lifecycle[key].remove(plugin[key]);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    inherit({ lifecycle, registerPlugins }) {
+        Object.keys(lifecycle).forEach((hookName)=>{
+            assert(!this.lifecycle[hookName], `"${hookName}" hook has conflict and cannot be inherited.`);
+            this.lifecycle[hookName] = lifecycle[hookName];
+        });
+        Object.keys(registerPlugins).forEach((pluginName)=>{
+            assert(!this.registerPlugins[pluginName], `"${pluginName}" plugin has conflict and cannot be inherited.`);
+            this.usePlugin(registerPlugins[pluginName]);
+        });
+    }
+    constructor(lifecycle){
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
+}
+
+function defaultPreloadArgs(preloadConfig) {
+    return _extends({
+        resourceCategory: 'sync',
+        share: true,
+        depsRemote: true
+    }, preloadConfig);
+}
+function formatPreloadArgs(remotes, preloadArgs) {
+    // let preloadOps: PreloadOptions;
+    return preloadArgs.map((args)=>{
+        const remoteInfo = matchRemote(remotes, args.nameOrAlias);
+        assert(remoteInfo, `can't preload ${args.nameOrAlias}，it is no't include in ${!remoteInfo && safeToString$1({
+            remoteInfo,
+            remotes
+        })} `);
+        return {
+            remote: remoteInfo,
+            preloadConfig: defaultPreloadArgs(args)
+        };
+    });
+}
+function normalizePreloadExposes(exposes) {
+    if (!exposes) {
+        return [];
+    }
+    return exposes.map((expose)=>{
+        if (expose === '.') {
+            return expose;
+        }
+        if (expose.startsWith('./')) {
+            return expose.replace('./', '');
+        }
+        return expose;
+    });
+}
+function preloadAssets(remoteInfo, host, assets) {
+    const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
+    if (host.options.inBrowser) {
+        entryAssets.forEach((asset)=>{
+            const { moduleInfo } = asset;
+            const module = host.moduleCache.get(remoteInfo.name);
+            if (module) {
+                getRemoteEntry({
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: module.remoteEntryExports,
+                    createScriptHook: (url)=>{
+                        const res = host.loaderHook.lifecycle.createScript.emit({
+                            url
+                        });
+                        if (res instanceof HTMLScriptElement) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+            } else {
+                getRemoteEntry({
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: undefined,
+                    createScriptHook: (url)=>{
+                        const res = host.loaderHook.lifecycle.createScript.emit({
+                            url
+                        });
+                        if (res instanceof HTMLScriptElement) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+            }
+        });
+        const fragment = document.createDocumentFragment();
+        cssAssets.forEach((cssUrl)=>{
+            const cssEl = document.createElement('link');
+            cssEl.setAttribute('rel', 'preload');
+            cssEl.setAttribute('href', cssUrl);
+            cssEl.setAttribute('as', 'style');
+            cssEl.setAttribute('crossorigin', 'anonymous');
+            fragment.appendChild(cssEl);
+        });
+        document.head.appendChild(fragment);
+        jsAssetsWithoutEntry.forEach((jsUrl)=>{
+            const { script: scriptEl } = createScript(jsUrl, ()=>{
+            // noop
+            }, {}, (url)=>{
+                const res = host.loaderHook.lifecycle.createScript.emit({
+                    url
+                });
+                if (res instanceof HTMLScriptElement) {
+                    return res;
+                }
+                return;
+            });
+            document.head.appendChild(scriptEl);
+        });
+    }
+}
+
+function assignRemoteInfo(remoteInfo, remoteSnapshot) {
+    if (!('remoteEntry' in remoteSnapshot) || !remoteSnapshot.remoteEntry) {
+        error(`The remoteEntry attribute of ${name} cannot be undefined.`);
+    }
+    const { remoteEntry } = remoteSnapshot;
+    const entryUrl = getResourceUrl(remoteSnapshot, remoteEntry);
+    remoteInfo.type = remoteSnapshot.remoteEntryType;
+    remoteInfo.entryGlobalName = remoteSnapshot.globalName;
+    remoteInfo.entry = entryUrl;
+    remoteInfo.version = remoteSnapshot.version;
+    remoteInfo.buildVersion = remoteSnapshot.buildVersion;
+}
+function snapshotPlugin() {
+    return {
+        name: 'snapshot-plugin',
+        async loadRemoteMatch (args) {
+            const { remote, pkgNameOrAlias, expose, origin, remoteInfo } = args;
+            if (!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote)) {
+                const { remoteSnapshot, globalSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo(remote);
+                assignRemoteInfo(remoteInfo, remoteSnapshot);
+                // preload assets
+                const preloadOptions = {
+                    remote,
+                    preloadConfig: {
+                        nameOrAlias: pkgNameOrAlias,
+                        exposes: [
+                            expose
+                        ],
+                        resourceCategory: 'sync',
+                        share: false,
+                        depsRemote: false
+                    }
+                };
+                const assets = await origin.hooks.lifecycle.generatePreloadAssets.emit({
+                    origin,
+                    preloadOptions,
+                    remoteInfo,
+                    remote,
+                    remoteSnapshot,
+                    globalSnapshot
+                });
+                if (assets) {
+                    preloadAssets(remoteInfo, origin, assets);
+                }
+            }
+            return args;
+        }
+    };
+}
+
+// name
+// name:version
+function splitId(id) {
+    const splitInfo = id.split(':');
+    if (splitInfo.length === 1) {
+        return {
+            name: splitInfo[0],
+            version: undefined
+        };
+    } else if (splitInfo.length === 2) {
+        return {
+            name: splitInfo[0],
+            version: splitInfo[1]
+        };
+    } else {
+        return {
+            name: splitInfo[1],
+            version: splitInfo[2]
+        };
+    }
+}
+// Traverse all nodes through moduleInfo and traverse the entire snapshot
+function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot, memo = {}, remoteSnapshot, getModuleInfoHook) {
+    const id = getFMId(remoteInfo);
+    const { value: snapshotValue } = getInfoWithoutType(globalSnapshot, id, getModuleInfoHook);
+    const effectRemoteSnapshot = remoteSnapshot || snapshotValue;
+    if (effectRemoteSnapshot && !isManifestProvider(effectRemoteSnapshot)) {
+        traverse(effectRemoteSnapshot, remoteInfo, isRoot);
+        if (effectRemoteSnapshot.remotesInfo) {
+            const remoteKeys = Object.keys(effectRemoteSnapshot.remotesInfo);
+            for (const key of remoteKeys){
+                if (memo[key]) {
+                    continue;
+                }
+                memo[key] = true;
+                const subRemoteInfo = splitId(key);
+                const remoteValue = effectRemoteSnapshot.remotesInfo[key];
+                traverseModuleInfo(globalSnapshot, {
+                    name: subRemoteInfo.name,
+                    version: remoteValue.matchedVersion
+                }, traverse, false, memo, undefined, getModuleInfoHook);
+            }
+        }
+    }
+}
+// eslint-disable-next-line max-lines-per-function
+function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, remoteSnapshot) {
+    const cssAssets = [];
+    const jsAssets = [];
+    const entryAssets = [];
+    const loadedSharedJsAssets = new Set();
+    const loadedSharedCssAssets = new Set();
+    const { options } = origin;
+    const { preloadConfig: rootPreloadConfig } = preloadOptions;
+    const { depsRemote } = rootPreloadConfig;
+    const memo = {};
+    traverseModuleInfo(globalSnapshot, remote, (moduleInfoSnapshot, remoteInfo, isRoot)=>{
+        let preloadConfig;
+        if (isRoot) {
+            preloadConfig = rootPreloadConfig;
+        } else {
+            if (Array.isArray(depsRemote)) {
+                // eslint-disable-next-line array-callback-return
+                const findPreloadConfig = depsRemote.find((remoteConfig)=>{
+                    if (remoteConfig.nameOrAlias === remoteInfo.name || remoteConfig.nameOrAlias === remoteInfo.alias) {
+                        return true;
+                    }
+                    return false;
+                });
+                if (!findPreloadConfig) {
+                    return;
+                }
+                preloadConfig = defaultPreloadArgs(findPreloadConfig);
+            } else if (depsRemote === true) {
+                preloadConfig = rootPreloadConfig;
+            } else {
+                return;
+            }
+        }
+        const remoteEntryUrl = getResourceUrl(moduleInfoSnapshot, 'remoteEntry' in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntry : '');
+        if (remoteEntryUrl) {
+            entryAssets.push({
+                name: remoteInfo.name,
+                moduleInfo: {
+                    name: remoteInfo.name,
+                    entry: remoteEntryUrl,
+                    type: 'remoteEntryType' in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntryType : 'global',
+                    entryGlobalName: 'globalName' in moduleInfoSnapshot ? moduleInfoSnapshot.globalName : remoteInfo.name,
+                    shareScope: '',
+                    version: 'version' in moduleInfoSnapshot ? moduleInfoSnapshot.version : undefined
+                },
+                url: remoteEntryUrl
+            });
+        }
+        let moduleAssetsInfo = 'modules' in moduleInfoSnapshot ? moduleInfoSnapshot.modules : [];
+        const normalizedPreloadExposes = normalizePreloadExposes(preloadConfig.exposes);
+        if (normalizedPreloadExposes.length && 'modules' in moduleInfoSnapshot) {
+            var _moduleInfoSnapshot_modules;
+            moduleAssetsInfo = moduleInfoSnapshot == null ? void 0 : (_moduleInfoSnapshot_modules = moduleInfoSnapshot.modules) == null ? void 0 : _moduleInfoSnapshot_modules.reduce((assets, moduleAssetInfo)=>{
+                if ((normalizedPreloadExposes == null ? void 0 : normalizedPreloadExposes.indexOf(moduleAssetInfo.moduleName)) !== -1) {
+                    assets.push(moduleAssetInfo);
+                }
+                return assets;
+            }, []);
+        }
+        function handlerAssets(assets) {
+            const assetsRes = assets.map((asset)=>getResourceUrl(moduleInfoSnapshot, asset));
+            if (preloadConfig.filter) {
+                return assetsRes.filter(preloadConfig.filter);
+            }
+            return assetsRes;
+        }
+        if (moduleAssetsInfo) {
+            const assetsLength = moduleAssetsInfo.length;
+            for(let index = 0; index < assetsLength; index++){
+                const assetsInfo = moduleAssetsInfo[index];
+                // for (const assetsInfo of moduleAssetsInfo) {
+                const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;
+                const preloaded = getPreloaded(exposeFullPath);
+                if (preloaded) {
+                    continue;
+                }
+                if (preloadConfig.resourceCategory === 'all') {
+                    cssAssets.push(...handlerAssets(assetsInfo.assets.css.async));
+                    cssAssets.push(...handlerAssets(assetsInfo.assets.css.sync));
+                    jsAssets.push(...handlerAssets(assetsInfo.assets.js.async));
+                    jsAssets.push(...handlerAssets(assetsInfo.assets.js.sync));
+                // eslint-disable-next-line no-constant-condition
+                } else if (preloadConfig.resourceCategory = 'sync') {
+                    cssAssets.push(...handlerAssets(assetsInfo.assets.css.sync));
+                    jsAssets.push(...handlerAssets(assetsInfo.assets.js.sync));
+                }
+                setPreloaded(exposeFullPath);
+            }
+        }
+    }, true, memo, remoteSnapshot, (target, key)=>{
+        const res = origin.loaderHook.lifecycle.getModuleInfo.emit({
+            target,
+            key
+        });
+        if (res && !(res instanceof Promise)) {
+            return res;
+        }
+        return;
+    });
+    if (remoteSnapshot.shared) {
+        remoteSnapshot.shared.forEach((shared)=>{
+            var _options_shared;
+            const shareInfo = (_options_shared = options.shared) == null ? void 0 : _options_shared[shared.sharedName];
+            // When data is downgraded, the shared configuration may be different.
+            if (!shareInfo) {
+                return;
+            }
+            const globalShare = getGlobalShare(shared.sharedName, shareInfo);
+            // If the global share does not exist, or the lib function does not exist, it means that the shared has not been loaded yet and can be preloaded.
+            if (globalShare && typeof globalShare.lib === 'function') {
+                shared.assets.js.sync.forEach((asset)=>{
+                    loadedSharedJsAssets.add(asset);
+                });
+                shared.assets.css.sync.forEach((asset)=>{
+                    loadedSharedCssAssets.add(asset);
+                });
+            }
+        });
+    }
+    const needPreloadJsAssets = jsAssets.filter((asset)=>!loadedSharedJsAssets.has(asset));
+    const needPreloadCssAssets = cssAssets.filter((asset)=>!loadedSharedCssAssets.has(asset));
+    return {
+        cssAssets: needPreloadCssAssets,
+        jsAssetsWithoutEntry: needPreloadJsAssets,
+        entryAssets
+    };
+}
+const generatePreloadAssetsPlugin = function() {
+    return {
+        name: 'generate-preload-assets-plugin',
+        async generatePreloadAssets (args) {
+            const { origin, preloadOptions, remoteInfo, remote, globalSnapshot, remoteSnapshot } = args;
+            if (isRemoteInfoWithEntry(remote) && isPureRemoteEntry(remote)) {
+                return {
+                    cssAssets: [],
+                    jsAssetsWithoutEntry: [],
+                    entryAssets: [
+                        {
+                            name: remote.name,
+                            url: remote.entry,
+                            moduleInfo: {
+                                name: remoteInfo.name,
+                                entry: remote.entry,
+                                type: 'global',
+                                entryGlobalName: '',
+                                shareScope: ''
+                            }
+                        }
+                    ]
+                };
+            }
+            assignRemoteInfo(remoteInfo, remoteSnapshot);
+            const assets = generatePreloadAssets(origin, preloadOptions, remoteInfo, globalSnapshot, remoteSnapshot);
+            return assets;
+        }
+    };
+};
+
+class SnapshotHandler {
+    async loadSnapshot(moduleInfo) {
+        const { options } = this.HostInstance;
+        const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } = this.getGlobalRemoteInfo(moduleInfo);
+        const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes } = await this.hooks.lifecycle.loadSnapshot.emit({
+            options,
+            moduleInfo,
+            hostGlobalSnapshot,
+            remoteSnapshot,
+            globalSnapshot
+        });
+        return {
+            remoteSnapshot: globalRemoteSnapshot,
+            globalSnapshot: globalSnapshotRes
+        };
+    }
+    // eslint-disable-next-line max-lines-per-function
+    async loadRemoteSnapshotInfo(moduleInfo) {
+        const { options } = this.HostInstance;
+        const hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
+            name: this.HostInstance.options.name,
+            version: this.HostInstance.options.version
+        }, {
+            getModuleInfoHook: (target, key)=>{
+                const res = this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                    target,
+                    key
+                });
+                if (res && !(res instanceof Promise)) {
+                    return res;
+                }
+                return;
+            }
+        });
+        await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
+            options,
+            moduleInfo
+        });
+        // In the dynamic loadRemote scenario, incomplete remotesInfo delivery may occur. In this case, the remotesInfo in the host needs to be completed in the snapshot at runtime.
+        // Ensure the integrity of the snapshot, and at the same time help the chrome plug-in correctly identify all producer modules, ensuring that proxyable producer modules will not be missing
+        // In the dynamic loadRemote scenario, incomplete remotesInfo delivery may occur. In this case, the remotesInfo in the host needs to be completed in the snapshot at runtime.
+        // Ensure the integrity of the snapshot, and at the same time help the chrome plug-in correctly identify all producer modules, ensuring that proxyable producer modules will not be missing
+        if (hostSnapshot && 'remotesInfo' in hostSnapshot && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name, (target, key)=>{
+            const res = this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                target,
+                key
+            });
+            if (res && !(res instanceof Promise)) {
+                return res;
+            }
+            return;
+        }).value) {
+            if ('version' in moduleInfo || 'entry' in moduleInfo) {
+                hostSnapshot.remotesInfo = _extends({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
+                    [moduleInfo.name]: {
+                        matchedVersion: 'version' in moduleInfo ? moduleInfo.version : moduleInfo.entry
+                    }
+                });
+            }
+        }
+        const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } = this.getGlobalRemoteInfo(moduleInfo);
+        const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes } = await this.hooks.lifecycle.loadSnapshot.emit({
+            options,
+            moduleInfo,
+            hostGlobalSnapshot,
+            remoteSnapshot,
+            globalSnapshot
+        });
+        // global snapshot include manifest or module info include manifest
+        if (globalRemoteSnapshot) {
+            if (isManifestProvider(globalRemoteSnapshot)) {
+                const moduleSnapshot = await this.getManifestJson(globalRemoteSnapshot.remoteEntry, moduleInfo, {});
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(_extends({}, moduleInfo), moduleSnapshot);
+                return {
+                    remoteSnapshot: moduleSnapshot,
+                    globalSnapshot: globalSnapshotRes
+                };
+            } else {
+                const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+                    options: this.HostInstance.options,
+                    moduleInfo,
+                    remoteSnapshot: globalRemoteSnapshot,
+                    from: 'global'
+                });
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
+            }
+        } else {
+            if (isRemoteInfoWithEntry(moduleInfo)) {
+                // get from manifest.json and merge remote info from remote server
+                const moduleSnapshot = await this.getManifestJson(moduleInfo.entry, moduleInfo, {});
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(moduleInfo, moduleSnapshot);
+                const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+                    options: this.HostInstance.options,
+                    moduleInfo,
+                    remoteSnapshot: moduleSnapshot,
+                    from: 'global'
+                });
+                return {
+                    remoteSnapshot: remoteSnapshotRes,
+                    globalSnapshot: globalSnapshotRes
+                };
+            } else {
+                error(`
+          Cannot get remoteSnapshot with the name: '${moduleInfo.name}', version: '${moduleInfo.version}' from __FEDERATION__.moduleInfo. The following reasons may be causing the problem:\n
+          1. The Deploy platform did not deliver the correct data. You can use __FEDERATION__.moduleInfo to check the remoteInfo.\n
+          2. The remote '${moduleInfo.name}' version '${moduleInfo.version}' is not released.\n
+          The transformed module info: ${JSON.stringify(globalSnapshotRes)}
+        `);
+            }
+        }
+    }
+    getGlobalRemoteInfo(moduleInfo) {
+        const hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({
+            name: this.HostInstance.options.name,
+            version: this.HostInstance.options.version
+        }, {
+            getModuleInfoHook: (target, key)=>{
+                const res = this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                    target,
+                    key
+                });
+                if (res && !(res instanceof Promise)) {
+                    return res;
+                }
+                return;
+            }
+        });
+        // get remote detail info from global
+        const globalRemoteInfo = hostGlobalSnapshot && 'remotesInfo' in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name, (target, key)=>{
+            const res = this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                target,
+                key
+            });
+            if (res && !(res instanceof Promise)) {
+                return res;
+            }
+            return;
+        }).value;
+        if (globalRemoteInfo && globalRemoteInfo.matchedVersion) {
+            return {
+                hostGlobalSnapshot,
+                globalSnapshot: getGlobalSnapshot(),
+                remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+                    name: moduleInfo.name,
+                    version: globalRemoteInfo.matchedVersion
+                }, {
+                    getModuleInfoHook: (target, key)=>{
+                        const res = this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                            target,
+                            key
+                        });
+                        if (res && !(res instanceof Promise)) {
+                            return res;
+                        }
+                        return;
+                    }
+                })
+            };
+        }
+        return {
+            hostGlobalSnapshot: undefined,
+            globalSnapshot: getGlobalSnapshot(),
+            remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
+                name: moduleInfo.name,
+                version: 'version' in moduleInfo ? moduleInfo.version : undefined
+            }, {
+                getModuleInfoHook: (target, key)=>{
+                    const res = this.HostInstance.loaderHook.lifecycle.getModuleInfo.emit({
+                        target,
+                        key
+                    });
+                    if (res && !(res instanceof Promise)) {
+                        return res;
+                    }
+                    return;
+                }
+            })
+        };
+    }
+    async getManifestJson(manifestUrl, moduleInfo, extraOptions) {
+        const getManifest = async ()=>{
+            let manifestJson = this.manifestCache.get(manifestUrl);
+            if (manifestJson) {
+                return manifestJson;
+            }
+            try {
+                const res = await fetch(manifestUrl);
+                manifestJson = await res.json();
+                assert(manifestJson.metaData && manifestJson.exposes && manifestJson.shared, `${manifestUrl} is not federation manifest`);
+                this.manifestCache.set(manifestUrl, manifestJson);
+                return manifestJson;
+            } catch (err) {
+                error(`Failed to get manifestJson for ${moduleInfo.name}. The manifest URL is ${manifestUrl}. Please ensure that the manifestUrl is accessible.
+          \n Error message:
+          \n ${err}`);
+            }
+        };
+        const asyncLoadProcess = async ()=>{
+            const manifestJson = await getManifest();
+            const remoteSnapshot = generateSnapshotFromManifest(manifestJson, {
+                version: manifestUrl
+            });
+            const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
+                options: this.HostInstance.options,
+                moduleInfo,
+                manifestJson,
+                remoteSnapshot,
+                manifestUrl,
+                from: 'manifest'
+            });
+            return remoteSnapshotRes;
+        };
+        if (!this.manifestLoading[manifestUrl]) {
+            this.manifestLoading[manifestUrl] = asyncLoadProcess().then((res)=>res);
+        }
+        return this.manifestLoading[manifestUrl];
+    }
+    constructor(HostInstance){
+        this.loadingHostSnapshot = null;
+        this.manifestCache = 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;
+    }
+}
+
+class FederationHost {
+    initOptions(userOptions) {
+        this.registerPlugins(userOptions.plugins);
+        const options = this.formatOptions(this.options, userOptions);
+        this.options = options;
+        return options;
+    }
+    // overrideSharedOptions(shareScope: GlobalShareScope[string]): void {}
+    async loadShare(pkgName, customShareInfo) {
+        var _this_options_shared;
+        // 1. Verify whether the currently loaded share already exists, and report an error if it does not exist
+        // 2. Search globally to see if there is a matching share, and if so, use it directly
+        // 3. If not, get it from the current share and store the obtained share globally.
+        const shareInfo = Object.assign({}, (_this_options_shared = this.options.shared) == null ? void 0 : _this_options_shared[pkgName], customShareInfo);
+        const loadShareRes = await this.hooks.lifecycle.beforeLoadShare.emit({
+            pkgName,
+            shareInfo,
+            shared: this.options.shared,
+            origin: this
+        });
+        const { shareInfo: shareInfoRes } = loadShareRes;
+        assert(shareInfoRes, `cannot find ${pkgName} Share in the ${this.options.name}. Perhaps you have not injected the ${pkgName} Share parameters`);
+        // get from cache
+        const globalShare = getGlobalShare(pkgName, shareInfoRes);
+        if (globalShare && globalShare.lib) {
+            addUniqueItem(globalShare.useIn, this.options.name);
+            return globalShare.lib;
+        } else if (globalShare && globalShare.loading) {
+            const factory = await globalShare.loading;
+            addUniqueItem(globalShare.useIn, this.options.name);
+            return factory;
+        } else if (globalShare) {
+            const asyncLoadProcess = async ()=>{
+                const factory = await globalShare.get();
+                shareInfoRes.lib = factory;
+                addUniqueItem(shareInfoRes.useIn, this.options.name);
+                const gShared = getGlobalShare(pkgName, shareInfoRes);
+                if (gShared) {
+                    gShared.lib = factory;
+                }
+                return factory;
+            };
+            const loading = asyncLoadProcess();
+            this.setShared({
+                pkgName,
+                loaded: true,
+                shared: shareInfoRes,
+                from: this.options.name,
+                lib: null,
+                loading
+            });
+            return loading;
+        } else {
+            if (customShareInfo) {
+                return false;
+            }
+            const asyncLoadProcess = async ()=>{
+                const factory = await shareInfoRes.get();
+                shareInfoRes.lib = factory;
+                addUniqueItem(shareInfoRes.useIn, this.options.name);
+                const gShared = getGlobalShare(pkgName, shareInfoRes);
+                if (gShared) {
+                    gShared.lib = factory;
+                }
+                return factory;
+            };
+            const loading = asyncLoadProcess();
+            this.setShared({
+                pkgName,
+                loaded: true,
+                shared: shareInfoRes,
+                from: this.options.name,
+                lib: null,
+                loading
+            });
+            return loading;
+        }
+    }
+    // There will be a lib function only if the shared set by eager or runtime init is set or the shared is successfully loaded.
+    // 1. If the loaded shared already exists globally, then reuse
+    // 2. If lib exists in local shared, use it directly
+    // 3. If the local get returns something other than Promise, then use it directly
+    loadShareSync(pkgName) {
+        var _this_options_shared;
+        const shareInfo = (_this_options_shared = this.options.shared) == null ? void 0 : _this_options_shared[pkgName];
+        const globalShare = getGlobalShare(pkgName, shareInfo);
+        if (globalShare && typeof globalShare.lib === 'function') {
+            addUniqueItem(globalShare.useIn, this.options.name);
+            if (!globalShare.loaded) {
+                globalShare.loaded = true;
+                if (globalShare.from === this.options.name) {
+                    shareInfo.loaded = true;
+                }
+            }
+            return globalShare.lib;
+        }
+        if (shareInfo.lib) {
+            if (!shareInfo.loaded) {
+                shareInfo.loaded = true;
+            }
+            return shareInfo.lib;
+        }
+        if (shareInfo.get) {
+            const module = shareInfo.get();
+            if (module instanceof Promise) {
+                throw new Error(`
+        The loadShareSync function failed to load ${pkgName}. Cannot find ${pkgName} in ${this.options.name}.
+        Failure reason: \n
+        1. Registered ${pkgName} share with the 'get' attribute, but did not use loadShare before.\n
+        2. Did not register ${pkgName} share with the 'lib' attribute.\n
+      `);
+            }
+            shareInfo.lib = module;
+            this.setShared({
+                pkgName,
+                loaded: true,
+                from: this.options.name,
+                lib: shareInfo.lib,
+                shared: shareInfo
+            });
+            return shareInfo.lib;
+        }
+        throw new Error(`
+        The loadShareSync function failed to load ${pkgName}. Cannot find ${pkgName} in ${this.options.name}.
+        Failure reason: \n
+        1. Registered ${pkgName} share with the 'get' attribute, but did not use loadShare before.\n
+        2. Did not register ${pkgName} share with the 'lib' attribute.\n
+      `);
+    }
+    async _getRemoteModuleAndOptions(id) {
+        const loadRemoteArgs = await this.hooks.lifecycle.beforeLoadRemote.emit({
+            id,
+            options: this.options,
+            origin: this
+        });
+        const { id: idRes } = loadRemoteArgs;
+        const remoteSplitInfo = matchRemoteWithNameAndExpose(this.options.remotes, idRes);
+        assert(remoteSplitInfo, `
+        Cannot find ${idRes} in ${this.options.name}. Possible cause of failure:\n
+        1. ${idRes} was not injected into ${this.options.name}'s 'remotes' parameter.\n
+        2. Cannot find ${idRes} in ${this.options.name}'s 'remotes' with attribute 'name' or 'alias'.
+        3. The 'beforeLoadRemote' hook was provided but did not return the correct 'remoteInfo' when loading ${idRes}.
+      `);
+        const { remote: rawRemote } = remoteSplitInfo;
+        const remoteInfo = getRemoteInfo(rawRemote);
+        const matchInfo = await this.hooks.lifecycle.loadRemoteMatch.emit(_extends({
+            id: idRes
+        }, remoteSplitInfo, {
+            options: this.options,
+            origin: this,
+            remoteInfo
+        }));
+        const { remote, expose } = matchInfo;
+        assert(remote && expose, `The 'beforeLoadRemote' hook was provided but did not return the correct 'remote' and 'expose' when loading ${idRes}.`);
+        let module = this.moduleCache.get(remote.name);
+        const moduleOptions = {
+            hostInfo: {
+                name: this.options.name,
+                version: this.options.version || 'custom'
+            },
+            remoteInfo,
+            shared: this.options.shared || {},
+            plugins: this.options.plugins,
+            loaderHook: this.loaderHook
+        };
+        if (!module) {
+            module = new Module(moduleOptions);
+            this.moduleCache.set(remote.name, module);
+        }
+        return {
+            module,
+            moduleOptions,
+            remoteMatchInfo: matchInfo
+        };
+    }
+    // eslint-disable-next-line max-lines-per-function
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    async loadRemote(id, options) {
+        try {
+            const { loadFactory = true } = options || {
+                loadFactory: true
+            };
+            // 1. Verify whether the parameters of the obtained module are legal. There are two module request methods: pkgName + expose and alias + expose.
+            // 2. Request the snapshot information of the current host and store the obtained snapshot information globally. The obtained module information is partly offline and partly online. The online module information will obtain the modules used online.
+            // 3. Get the detailed information of the current module from global (remoteEntry address, expose resource address)
+            // 4. After obtaining remoteEntry, call the init of the module, and then obtain the exported content of the module through get
+            // id: pkgName(@federation/app1) + expose(button) = @federation/app1/button
+            // id: alias(app1) + expose(button) = app1/button
+            // id: alias(app1/utils) + expose(loadash/sort) = app1/utils/loadash/sort
+            const { module, moduleOptions, remoteMatchInfo } = await this._getRemoteModuleAndOptions(id);
+            const { pkgNameOrAlias, remote, expose, id: idRes } = remoteMatchInfo;
+            const moduleOrFactory = await module.get(expose, options);
+            await this.hooks.lifecycle.loadRemote.emit({
+                id: idRes,
+                pkgNameOrAlias,
+                expose,
+                exposeModule: loadFactory ? moduleOrFactory : undefined,
+                exposeModuleFactory: loadFactory ? undefined : moduleOrFactory,
+                remote,
+                options: moduleOptions,
+                moduleInstance: module,
+                origin: this
+            });
+            return moduleOrFactory;
+        } catch (error) {
+            this.hooks.lifecycle.errorLoadRemote.emit({
+                id,
+                error
+            });
+            throw error;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    async preloadRemote(preloadOptions) {
+        await this.hooks.lifecycle.beforePreloadRemote.emit({
+            preloadOptions,
+            options: this.options,
+            origin: this
+        });
+        const preloadOps = formatPreloadArgs(this.options.remotes, preloadOptions);
+        await Promise.all(preloadOps.map(async (ops)=>{
+            const { remote } = ops;
+            const remoteInfo = getRemoteInfo(remote);
+            const { globalSnapshot, remoteSnapshot } = await this.snapshotHandler.loadRemoteSnapshotInfo(remote);
+            const assets = await this.hooks.lifecycle.generatePreloadAssets.emit({
+                origin: this,
+                preloadOptions: ops,
+                remote,
+                remoteInfo,
+                globalSnapshot,
+                remoteSnapshot
+            });
+            if (!assets) {
+                return;
+            }
+            preloadAssets(remoteInfo, this, assets);
+        }));
+    }
+    /**
+   * The sharing init sequence function (only runs once per share scope).
+   * Has one argument, the name of the share scope.
+   * Creates a share scope if not existing
+   */ // eslint-disable-next-line @typescript-eslint/member-ordering
+    initializeSharing(shareScopeName = DEFAULT_SCOPE) {
+        const shareScopeLoading = Global.__FEDERATION__.__SHARE_SCOPE_LOADING__;
+        const shareScope = Global.__FEDERATION__.__SHARE__;
+        const hostName = this.options.name;
+        // only runs once
+        if (shareScopeLoading[shareScopeName]) {
+            return shareScopeLoading[shareScopeName];
+        }
+        // creates a new share scope if needed
+        if (!shareScope[shareScopeName]) {
+            shareScope[shareScopeName] = {};
+        }
+        // runs all init snippets from all modules reachable
+        const scope = shareScope[shareScopeName];
+        const register = (name, shared)=>{
+            const { version, eager } = shared;
+            scope[name] = scope[name] || {};
+            const versions = scope[name];
+            const activeVersion = versions[version];
+            const activeVersionEager = Boolean(activeVersion && (activeVersion.eager || activeVersion.shareConfig.eager));
+            if (!activeVersion || !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > activeVersion.from)) {
+                versions[version] = shared;
+            }
+        };
+        const promises = [];
+        const initRemoteModule = async (key)=>{
+            const { module } = await this._getRemoteModuleAndOptions(key);
+            const initFn = (mod)=>mod && mod.init && mod.init(shareScope[shareScopeName]);
+            const entry = await module.getEntry();
+            initFn(entry);
+        };
+        Object.keys(this.options.shared).forEach((shareName)=>{
+            const shared = this.options.shared[shareName];
+            if (shared.scope.includes(shareScopeName)) {
+                register(shareName, shared);
+            }
+        });
+        this.options.remotes.forEach((remote)=>{
+            if (remote.shareScope === shareScopeName) {
+                promises.push(initRemoteModule(remote.name));
+            }
+        });
+        if (!promises.length) {
+            return shareScopeLoading[shareScopeName] = true;
+        }
+        return shareScopeLoading[shareScopeName] = Promise.all(promises).then(()=>shareScopeLoading[shareScopeName] = true);
+    }
+    formatOptions(globalOptions, userOptions) {
+        const formatShareOptions = formatShareConfigs(userOptions.shared || {}, userOptions.name);
+        const shared = _extends({}, globalOptions.shared, formatShareOptions);
+        const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
+            origin: this,
+            userOptions,
+            options: globalOptions,
+            shareInfo: shared
+        });
+        const userRemotes = userOptionsRes.remotes || [];
+        const remotes = userRemotes.reduce((res, remote)=>{
+            if (!res.find((item)=>item.name === remote.name)) {
+                if (remote.alias) {
+                    // 校验 alias 是否等于 remote.name 和 remote.alias 的前缀，如果是则报错
+                    // 因为引用支持多级路径的引用时无法保证名称是否唯一，所以不支持 alias 为 remote.name 的前缀
+                    const findEqual = res.find((item)=>{
+                        var _item_alias;
+                        return remote.alias && (item.name.startsWith(remote.alias) || ((_item_alias = item.alias) == null ? void 0 : _item_alias.startsWith(remote.alias)));
+                    });
+                    assert(!findEqual, `The alias ${remote.alias} of remote ${remote.name} is not allowed to be the prefix of ${findEqual && findEqual.name} name or alias`);
+                }
+                // Set the remote entry to a complete path
+                if ('entry' in remote) {
+                    if (isBrowserEnv$1()) {
+                        remote.entry = new URL(remote.entry, window.location.origin).href;
+                    }
+                }
+                if (!remote.shareScope) {
+                    remote.shareScope = DEFAULT_SCOPE;
+                }
+                if (!remote.type) {
+                    // FIXME: The build plugin need to support this field
+                    remote.type = DEFAULT_REMOTE_TYPE;
+                }
+                res.push(remote);
+            }
+            return res;
+        }, globalOptionsRes.remotes);
+        // register shared include lib
+        const sharedKeys = Object.keys(formatShareOptions);
+        sharedKeys.forEach((sharedKey)=>{
+            const sharedVal = formatShareOptions[sharedKey];
+            const globalShare = getGlobalShare(sharedKey, sharedVal);
+            if (!globalShare && sharedVal && sharedVal.lib) {
+                this.setShared({
+                    pkgName: sharedKey,
+                    lib: sharedVal.lib,
+                    get: sharedVal.get,
+                    shared: sharedVal,
+                    from: userOptions.name
+                });
+            }
+        });
+        const plugins = [
+            ...globalOptionsRes.plugins
+        ];
+        if (userOptionsRes.plugins) {
+            userOptionsRes.plugins.forEach((plugin)=>{
+                if (!plugins.includes(plugin)) {
+                    plugins.push(plugin);
+                }
+            });
+        }
+        const optionsRes = _extends({}, globalOptions, userOptions, {
+            plugins,
+            remotes,
+            shared
+        });
+        this.hooks.lifecycle.init.emit({
+            origin: this,
+            options: optionsRes
+        });
+        return optionsRes;
+    }
+    registerPlugins(plugins) {
+        registerPlugins(plugins, [
+            this.hooks,
+            this.snapshotHandler.hooks,
+            this.loaderHook
+        ]);
+    }
+    setShared({ pkgName, shared, from, lib, loading, loaded, get }) {
+        const target = getGlobalShareScope();
+        const { version, scope = 'default' } = shared, shareInfo = _object_without_properties_loose(shared, [
+            "version",
+            "scope"
+        ]);
+        const scopes = Array.isArray(scope) ? scope : [
+            scope
+        ];
+        scopes.forEach((sc)=>{
+            if (!target[sc]) {
+                target[sc] = {};
+            }
+            if (!target[sc][pkgName]) {
+                target[sc][pkgName] = {};
+            }
+            if (target[sc][pkgName][version]) {
+                warn(// eslint-disable-next-line max-len
+                `The share \n ${safeToString$1({
+                    scope: sc,
+                    pkgName,
+                    version,
+                    from: target[sc][pkgName][version].from
+                })} has been registered`);
+                return;
+            }
+            target[sc][pkgName][version] = _extends({
+                version,
+                scope: [
+                    'default'
+                ]
+            }, shareInfo, {
+                lib,
+                loaded,
+                loading
+            });
+            if (get) {
+                target[sc][pkgName][version].get = get;
+            }
+        });
+    }
+    constructor(userOptions){
+        this.hooks = new PluginSystem({
+            beforeInit: new SyncWaterfallHook('beforeInit'),
+            init: new SyncHook(),
+            beforeLoadRemote: new AsyncWaterfallHook('beforeLoadRemote'),
+            loadRemoteMatch: new AsyncWaterfallHook('loadRemoteMatch'),
+            loadRemote: new AsyncHook('loadRemote'),
+            errorLoadRemote: new AsyncHook('errorLoadRemote'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
+            loadShare: new AsyncHook(),
+            beforePreloadRemote: new AsyncHook(),
+            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
+            afterPreloadRemote: new AsyncHook()
+        });
+        this.version = '0.0.1';
+        this.moduleCache = new Map();
+        this.loaderHook = new PluginSystem({
+            // FIXME: may not be suitable
+            getModuleInfo: new SyncHook(),
+            createScript: new SyncHook()
+        });
+        this.loadingShare = {};
+        // TODO: check options detail type
+        // set options default value
+        const defaultOptions = {
+            id: getBuilderId(),
+            name: userOptions.name,
+            plugins: [
+                snapshotPlugin(),
+                generatePreloadAssetsPlugin()
+            ],
+            remotes: [],
+            shared: {},
+            inBrowser: isBrowserEnv$1()
+        };
+        this.name = userOptions.name;
+        this.options = defaultOptions;
+        this.snapshotHandler = new SnapshotHandler(this);
+        this.registerPlugins([
+            ...defaultOptions.plugins,
+            ...userOptions.plugins || []
+        ]);
+        this.options = this.formatOptions(defaultOptions, userOptions);
+    }
+}
+
+let FederationInstance = null;
+function init(options) {
+    // Retrieve the same instance with the same name
+    const instance = getGlobalFederationInstance(options.name, options.version);
+    if (!instance) {
+        // Retrieve debug constructor
+        const FederationConstructor = getGlobalFederationConstructor() || FederationHost;
+        FederationInstance = new FederationConstructor(options);
+        setGlobalFederationInstance(FederationInstance);
+        return FederationInstance;
+    } else {
+        // Merge options
+        instance.initOptions(options);
+        return instance;
+    }
+}
+function loadRemote(...args) {
+    assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadRemote.apply(FederationInstance, args);
+}
+function loadShare(...args) {
+    assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadShare.apply(FederationInstance, args);
+}
+function loadShareSync(...args) {
+    assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadShareSync.apply(FederationInstance, args);
+}
+function preloadRemote(...args) {
+    assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.preloadRemote.apply(FederationInstance, args);
+}
+// Inject for debug
+setGlobalFederationConstructor(FederationHost);
+
+export { FederationHost, init, loadRemote, loadScript, loadShare, loadShareSync, preloadRemote };