@module-federation/runtime 0.0.0-canary-1701669627295

package/index.cjs.js

@@ -0,0 +1,1612 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var share = require('./share.cjs.js');
+var sdk = require('@module-federation/sdk');
+
+// Function to match a remote with its name and expose
+// 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 isNameMatched = id.startsWith(remote.name);
+        let expose = id.replace(remote.name, '');
+        if (isNameMatched) {
+            if (expose.startsWith('/')) {
+                const pkgNameOrAlias = remote.name;
+                expose = `.${expose}`;
+                return {
+                    pkgNameOrAlias,
+                    expose,
+                    remote
+                };
+            } else if (expose === '') {
+                return {
+                    pkgNameOrAlias: remote.name,
+                    expose: '.',
+                    remote
+                };
+            }
+        }
+        // match alias
+        const isAliasMatched = remote.alias && id.startsWith(remote.alias);
+        let exposeWithAlias = remote.alias && id.replace(remote.alias, '');
+        if (remote.alias && isAliasMatched) {
+            if (exposeWithAlias && exposeWithAlias.startsWith('/')) {
+                const pkgNameOrAlias = remote.alias;
+                exposeWithAlias = `.${exposeWithAlias}`;
+                return {
+                    pkgNameOrAlias,
+                    expose: exposeWithAlias,
+                    remote
+                };
+            } else if (exposeWithAlias === '') {
+                return {
+                    pkgNameOrAlias: remote.alias,
+                    expose: '.',
+                    remote
+                };
+            }
+        }
+    }
+    return;
+}
+// Function to match a remote with its name or alias
+function matchRemote(remotes, nameOrAlias) {
+    for (const remote of remotes){
+        const isNameMatched = nameOrAlias === remote.name;
+        if (isNameMatched) {
+            return remote;
+        }
+        const isAliasMatched = remote.alias && nameOrAlias === remote.alias;
+        if (isAliasMatched) {
+            return remote;
+        }
+    }
+    return;
+}
+
+function registerPlugins(plugins, hookInstances) {
+    const globalPlugins = share.getGlobalHostPlugins();
+    // Incorporate 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 _extends$5() {
+    _extends$5 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$5.apply(this, arguments);
+}
+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 } = share.getRemoteEntryExports(name, globalName);
+    if (remoteEntryExports) {
+        return remoteEntryExports;
+    }
+    return sdk.loadScript(entry, {
+        attrs: {},
+        createScriptHook
+    }).then(()=>{
+        const { remoteEntryKey, entryExports } = share.getRemoteEntryExports(name, globalName);
+        share.assert(entryExports, `
+      Unable to use the ${name}'s '${entry}' URL with ${remoteEntryKey}'s globalName to get remoteEntry exports.
+      Possible reasons could be:\n
+      1. '${entry}' is not the correct URL, or the remoteEntry resource or name is incorrect.\n
+      2. ${remoteEntryKey} cannot be used to get remoteEntry exports in the window object.
+    `);
+        return entryExports;
+    });
+}
+async function getRemoteEntry({ remoteEntryExports, remoteInfo, createScriptHook }) {
+    const { entry, name, type, entryGlobalName } = remoteInfo;
+    const uniqueKey = sdk.composeKeyWithSeparator(name, entry);
+    if (remoteEntryExports) {
+        return remoteEntryExports;
+    }
+    if (!share.globalLoading[uniqueKey]) {
+        if (type === 'esm') {
+            share.globalLoading[uniqueKey] = loadEsmEntry({
+                entry,
+                remoteEntryExports
+            });
+        } else {
+            share.globalLoading[uniqueKey] = loadEntryScript({
+                name,
+                globalName: entryGlobalName,
+                entry,
+                createScriptHook
+            });
+        }
+    }
+    return share.globalLoading[uniqueKey];
+}
+function getRemoteInfo(remote) {
+    return _extends$5({}, remote, {
+        entry: 'entry' in remote ? remote.entry : '',
+        type: remote.type || share.DEFAULT_REMOTE_TYPE,
+        entryGlobalName: remote.entryGlobalName || remote.name,
+        shareScope: remote.shareScope || share.DEFAULT_SCOPE
+    });
+}
+
+function _extends$4() {
+    _extends$4 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$4.apply(this, arguments);
+}
+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;
+            }
+        });
+        share.assert(remoteEntryExports, `remoteEntryExports is undefined \n ${share.safeToString(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 = share.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 = share.Global.__FEDERATION__.__INSTANCES__.find((i)=>i.options.id === sdk.composeKeyWithSeparator(this.remoteInfo.name, this.remoteInfo.buildVersion));
+            if (federationInstance) {
+                federationInstance.initOptions(_extends$4({}, remoteEntryInitOptions, {
+                    remotes: [],
+                    name: this.remoteInfo.name
+                }));
+            }
+        }
+        this.lib = remoteEntryExports;
+        this.inited = true;
+        // get exposeGetter
+        const moduleFactory = await remoteEntryExports.get(expose);
+        share.assert(moduleFactory, `${share.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(originalData, returnedData) {
+    if (!share.isObject(returnedData)) {
+        return false;
+    }
+    if (originalData !== returnedData) {
+        // eslint-disable-next-line no-restricted-syntax
+        for(const key in originalData){
+            if (!(key in returnedData)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+class SyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!share.isObject(data)) {
+            share.error(`The data for the "${this.type}" hook should be an object.`);
+        }
+        for (const fn of this.listeners){
+            try {
+                const tempData = fn(data);
+                if (checkReturnData(data, tempData)) {
+                    data = tempData;
+                } else {
+                    this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
+                    break;
+                }
+            } catch (e) {
+                share.warn(e);
+                this.onerror(e);
+            }
+        }
+        return data;
+    }
+    constructor(type){
+        super();
+        this.onerror = share.error;
+        this.type = type;
+    }
+}
+
+class AsyncWaterfallHook extends SyncHook {
+    emit(data) {
+        if (!share.isObject(data)) {
+            share.error(`The response data for the "${this.type}" hook must be an object.`);
+        }
+        const ls = Array.from(this.listeners);
+        if (ls.length > 0) {
+            let i = 0;
+            const processError = (e)=>{
+                share.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(`A plugin returned an incorrect value for the "${this.type}" type.`);
+                }
+                return data;
+            };
+            return Promise.resolve(call(data));
+        }
+        return Promise.resolve(data);
+    }
+    constructor(type){
+        super();
+        this.onerror = share.error;
+        this.type = type;
+    }
+}
+
+class PluginSystem {
+    usePlugin(plugin) {
+        share.assert(share.isPlainObject(plugin), 'Plugin configuration is invalid.');
+        // The plugin's name is mandatory and must be unique
+        const pluginName = plugin.name;
+        share.assert(pluginName, 'A name must be provided by the plugin.');
+        if (!this.registerPlugins[pluginName]) {
+            this.registerPlugins[pluginName] = plugin;
+            Object.keys(this.lifecycle).forEach((key)=>{
+                const pluginLife = plugin[key];
+                if (pluginLife) {
+                    this.lifecycle[key].on(pluginLife);
+                }
+            });
+        }
+    }
+    removePlugin(pluginName) {
+        share.assert(pluginName, 'A name is required.');
+        const plugin = this.registerPlugins[pluginName];
+        share.assert(plugin, `The plugin "${pluginName}" is not registered.`);
+        Object.keys(plugin).forEach((key)=>{
+            if (key !== 'name') {
+                this.lifecycle[key].remove(plugin[key]);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    inherit({ lifecycle, registerPlugins }) {
+        Object.keys(lifecycle).forEach((hookName)=>{
+            share.assert(!this.lifecycle[hookName], `The hook "${hookName}" has a conflict and cannot be inherited.`);
+            this.lifecycle[hookName] = lifecycle[hookName];
+        });
+        Object.keys(registerPlugins).forEach((pluginName)=>{
+            share.assert(!this.registerPlugins[pluginName], `The plugin "${pluginName}" has a conflict and cannot be inherited.`);
+            this.usePlugin(registerPlugins[pluginName]);
+        });
+    }
+    constructor(lifecycle){
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
+}
+
+function _extends$3() {
+    _extends$3 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$3.apply(this, arguments);
+}
+function defaultPreloadArgs(preloadConfig) {
+    return _extends$3({
+        resourceCategory: 'sync',
+        share: true,
+        depsRemote: true,
+        prefetchInterface: false
+    }, preloadConfig);
+}
+function formatPreloadArgs(remotes, preloadArgs) {
+    return preloadArgs.map((args)=>{
+        const remoteInfo = matchRemote(remotes, args.nameOrAlias);
+        share.assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && share.safeToString({
+            remoteInfo,
+            remotes
+        })}`);
+        return {
+            remote: remoteInfo,
+            preloadConfig: defaultPreloadArgs(args)
+        };
+    });
+}
+function normalizePreloadExposes(exposes) {
+    if (!exposes) {
+        return [];
+    }
+    return exposes.map((expose)=>{
+        if (expose === '.') {
+            return expose;
+        }
+        if (expose.startsWith('./')) {
+            return expose.replace('./', '');
+        }
+        return expose;
+    });
+}
+function preloadAssets(remoteInfo, host, assets) {
+    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');
+            fragment.appendChild(cssEl);
+        });
+        document.head.appendChild(fragment);
+        jsAssetsWithoutEntry.forEach((jsUrl)=>{
+            const { script: scriptEl } = sdk.createScript(jsUrl, ()=>{
+            // noop
+            }, {}, (url)=>{
+                const res = host.loaderHook.lifecycle.createScript.emit({
+                    url
+                });
+                if (res instanceof HTMLScriptElement) {
+                    return res;
+                }
+                return;
+            });
+            document.head.appendChild(scriptEl);
+        });
+    }
+}
+
+function _extends$2() {
+    _extends$2 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$2.apply(this, arguments);
+}
+function assignRemoteInfo(remoteInfo, remoteSnapshot) {
+    if (!('remoteEntry' in remoteSnapshot) || !remoteSnapshot.remoteEntry) {
+        share.error(`The attribute remoteEntry of ${name} must not be undefined.`);
+    }
+    const { remoteEntry } = remoteSnapshot;
+    const entryUrl = sdk.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 (!share.isRemoteInfoWithEntry(remote) || !share.isPureRemoteEntry(remote)) {
+                const { remoteSnapshot, globalSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo(remote);
+                assignRemoteInfo(remoteInfo, remoteSnapshot);
+                // preloading 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 _extends$2({}, args, {
+                    remoteSnapshot
+                });
+            }
+            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 in moduleInfo and traverse the entire snapshot
+function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot, memo = {}, remoteSnapshot, getModuleInfoHook) {
+    const id = share.getFMId(remoteInfo);
+    const { value: snapshotValue } = share.getInfoWithoutType(globalSnapshot, id, getModuleInfoHook);
+    const effectiveRemoteSnapshot = remoteSnapshot || snapshotValue;
+    if (effectiveRemoteSnapshot && !sdk.isManifestProvider(effectiveRemoteSnapshot)) {
+        traverse(effectiveRemoteSnapshot, remoteInfo, isRoot);
+        if (effectiveRemoteSnapshot.remotesInfo) {
+            const remoteKeys = Object.keys(effectiveRemoteSnapshot.remotesInfo);
+            for (const key of remoteKeys){
+                if (memo[key]) {
+                    continue;
+                }
+                memo[key] = true;
+                const subRemoteInfo = splitId(key);
+                const remoteValue = effectiveRemoteSnapshot.remotesInfo[key];
+                traverseModuleInfo(globalSnapshot, {
+                    name: subRemoteInfo.name,
+                    version: remoteValue.matchedVersion
+                }, traverse, false, memo, 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 = sdk.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 handleAssets(assets) {
+            const assetsRes = assets.map((asset)=>sdk.getResourceUrl(moduleInfoSnapshot, asset));
+            if (preloadConfig.filter) {
+                return assetsRes.filter(preloadConfig.filter);
+            }
+            return assetsRes;
+        }
+        if (moduleAssetsInfo) {
+            const assetsLength = moduleAssetsInfo.length;
+            for(let index = 0; index < assetsLength; index++){
+                const assetsInfo = moduleAssetsInfo[index];
+                const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;
+                origin.hooks.lifecycle.handlePreloadModule.emit({
+                    id: assetsInfo.moduleName === '.' ? remoteInfo.name : exposeFullPath,
+                    name: remoteInfo.name,
+                    remoteSnapshot: moduleInfoSnapshot,
+                    preloadConfig
+                });
+                const preloaded = share.getPreloaded(exposeFullPath);
+                if (preloaded) {
+                    continue;
+                }
+                if (preloadConfig.resourceCategory === 'all') {
+                    cssAssets.push(...handleAssets(assetsInfo.assets.css.async));
+                    cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
+                    jsAssets.push(...handleAssets(assetsInfo.assets.js.async));
+                    jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
+                // eslint-disable-next-line no-constant-condition
+                } else if (preloadConfig.resourceCategory = 'sync') {
+                    cssAssets.push(...handleAssets(assetsInfo.assets.css.sync));
+                    jsAssets.push(...handleAssets(assetsInfo.assets.js.sync));
+                }
+                share.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 = share.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 (share.isRemoteInfoWithEntry(remote) && share.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;
+        }
+    };
+};
+
+function _extends$1() {
+    _extends$1 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$1.apply(this, arguments);
+}
+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 = share.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 dynamic loadRemote scenarios, incomplete remotesInfo delivery may occur. In such cases, the remotesInfo in the host needs to be completed in the snapshot at runtime.
+        // This ensures the snapshot's integrity and helps the chrome plugin correctly identify all producer modules, ensuring that proxyable producer modules will not be missing.
+        if (hostSnapshot && 'remotesInfo' in hostSnapshot && !share.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$1({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
+                    [moduleInfo.name]: {
+                        matchedVersion: 'version' in moduleInfo ? moduleInfo.version : moduleInfo.entry
+                    }
+                });
+            }
+        }
+        const { hostGlobalSnapshot, remoteSnapshot, globalSnapshot } = this.getGlobalRemoteInfo(moduleInfo);
+        const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes } = await this.hooks.lifecycle.loadSnapshot.emit({
+            options,
+            moduleInfo,
+            hostGlobalSnapshot,
+            remoteSnapshot,
+            globalSnapshot
+        });
+        // global snapshot includes manifest or module info includes manifest
+        if (globalRemoteSnapshot) {
+            if (sdk.isManifestProvider(globalRemoteSnapshot)) {
+                const moduleSnapshot = await this.getManifestJson(globalRemoteSnapshot.remoteEntry, moduleInfo, {});
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                const globalSnapshotRes = share.setGlobalSnapshotInfoByModuleInfo(_extends$1({}, 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 (share.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 = share.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 {
+                share.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 = share.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 && share.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: share.getGlobalSnapshot(),
+                remoteSnapshot: share.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: share.getGlobalSnapshot(),
+            remoteSnapshot: share.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();
+                share.assert(manifestJson.metaData && manifestJson.exposes && manifestJson.shared, `${manifestUrl} is not a federation manifest`);
+                this.manifestCache.set(manifestUrl, manifestJson);
+                return manifestJson;
+            } catch (err) {
+                share.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 = sdk.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 = share.Global.__FEDERATION__.__MANIFEST_LOADING__;
+        this.HostInstance = HostInstance;
+    }
+}
+
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+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;
+        // This function performs the following steps:
+        // 1. Checks if the currently loaded share already exists, if not, it throws an error
+        // 2. Searches globally for a matching share, if found, it uses it directly
+        // 3. If not found, it retrieves it from the current share and stores 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 that shareInfoRes exists, if not, throw an error
+        share.assert(shareInfoRes, `Cannot find ${pkgName} Share in the ${this.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
+        // Retrieve from cache
+        const globalShare = share.getGlobalShare(pkgName, shareInfoRes);
+        if (globalShare && globalShare.lib) {
+            share.addUniqueItem(globalShare.useIn, this.options.name);
+            return globalShare.lib;
+        } else if (globalShare && globalShare.loading) {
+            const factory = await globalShare.loading;
+            share.addUniqueItem(globalShare.useIn, this.options.name);
+            return factory;
+        } else if (globalShare) {
+            const asyncLoadProcess = async ()=>{
+                const factory = await globalShare.get();
+                shareInfoRes.lib = factory;
+                share.addUniqueItem(shareInfoRes.useIn, this.options.name);
+                const gShared = share.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;
+                share.addUniqueItem(shareInfoRes.useIn, this.options.name);
+                const gShared = share.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;
+        }
+    }
+    // The lib function will only be available if the shared set by eager or runtime init is set or the shared is successfully loaded.
+    // 1. If the loaded shared already exists globally, then it will be reused
+    // 2. If lib exists in local shared, it will be used directly
+    // 3. If the local get returns something other than Promise, then it will be used directly
+    loadShareSync(pkgName) {
+        var _this_options_shared;
+        const shareInfo = (_this_options_shared = this.options.shared) == null ? void 0 : _this_options_shared[pkgName];
+        const globalShare = share.getGlobalShare(pkgName, shareInfo);
+        if (globalShare && typeof globalShare.lib === 'function') {
+            share.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 was unable to load ${pkgName}. The ${pkgName} could not be found in ${this.options.name}.
+        Possible reasons for failure: \n
+        1. The ${pkgName} share was registered with the 'get' attribute, but loadShare was not used beforehand.\n
+        2. The ${pkgName} share was not registered 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 was unable to load ${pkgName}. The ${pkgName} could not be found in ${this.options.name}.
+        Possible reasons for failure: \n
+        1. The ${pkgName} share was registered with the 'get' attribute, but loadShare was not used beforehand.\n
+        2. The ${pkgName} share was not registered 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);
+        share.assert(remoteSplitInfo, `
+        Unable to locate ${idRes} in ${this.options.name}. Potential reasons for failure include:\n
+        1. ${idRes} was not included in the 'remotes' parameter of ${this.options.name}.\n
+        2. ${idRes} could not be found in the 'remotes' of ${this.options.name} with either 'name' or 'alias' attributes.
+        3. The 'beforeLoadRemote' hook was provided but did not return the correct 'remoteInfo' when attempting to load ${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;
+        share.assert(remote && expose, `The 'beforeLoadRemote' hook was executed, but it failed to return the correct 'remote' and 'expose' values while 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. Validate the parameters of the retrieved module. There are two module request methods: pkgName + expose and alias + expose.
+            // 2. Request the snapshot information of the current host and globally store the obtained snapshot information. The retrieved module information is partially offline and partially online. The online module information will retrieve the modules used online.
+            // 3. Retrieve the detailed information of the current module from global (remoteEntry address, expose resource address)
+            // 4. After retrieving remoteEntry, call the init of the module, and then retrieve 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);
+        }));
+    }
+    /**
+   * This function initializes the sharing sequence (executed only once per share scope).
+   * It accepts one argument, the name of the share scope.
+   * If the share scope does not exist, it creates one.
+   */ // eslint-disable-next-line @typescript-eslint/member-ordering
+    initializeSharing(shareScopeName = share.DEFAULT_SCOPE) {
+        const shareScopeLoading = share.Global.__FEDERATION__.__SHARE_SCOPE_LOADING__;
+        const shareScope = share.Global.__FEDERATION__.__SHARE__;
+        const hostName = this.options.name;
+        // Executes only once
+        if (shareScopeLoading[shareScopeName]) {
+            return shareScopeLoading[shareScopeName];
+        }
+        // Creates a new share scope if necessary
+        if (!shareScope[shareScopeName]) {
+            shareScope[shareScopeName] = {};
+        }
+        // Executes all initialization snippets from all accessible modules
+        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 = share.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) {
+                    // Validate if alias equals the prefix of remote.name and remote.alias, if so, throw an error
+                    // As multi-level path references cannot guarantee unique names, alias being a prefix of remote.name is not supported
+                    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)));
+                    });
+                    share.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 (share.isBrowserEnv()) {
+                        remote.entry = new URL(remote.entry, window.location.origin).href;
+                    }
+                }
+                if (!remote.shareScope) {
+                    remote.shareScope = share.DEFAULT_SCOPE;
+                }
+                if (!remote.type) {
+                    // FIXME: The build plugin needs to support this field
+                    remote.type = share.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 = share.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 = share.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]) {
+                share.warn(// eslint-disable-next-line max-len
+                `The share \n ${share.safeToString({
+                    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'),
+            handlePreloadModule: new SyncHook('handlePreloadModule'),
+            errorLoadRemote: new AsyncHook('errorLoadRemote'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
+            loadShare: new AsyncHook(),
+            beforePreloadRemote: new AsyncHook(),
+            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
+            afterPreloadRemote: new AsyncHook()
+        });
+        this.version = '1.0.0-canary.5';
+        this.moduleCache = new Map();
+        this.loaderHook = new PluginSystem({
+            // FIXME: may not be suitable
+            getModuleInfo: new SyncHook(),
+            createScript: new SyncHook()
+        });
+        this.loadingShare = {};
+        // TODO: Validate the details of the options
+        // Initialize options with default values
+        const defaultOptions = {
+            id: share.getBuilderId(),
+            name: userOptions.name,
+            plugins: [
+                snapshotPlugin(),
+                generatePreloadAssetsPlugin()
+            ],
+            remotes: [],
+            shared: {},
+            inBrowser: share.isBrowserEnv()
+        };
+        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 = share.getGlobalFederationInstance(options.name, options.version);
+    if (!instance) {
+        // Retrieve debug constructor
+        const FederationConstructor = share.getGlobalFederationConstructor() || FederationHost;
+        FederationInstance = new FederationConstructor(options);
+        share.setGlobalFederationInstance(FederationInstance);
+        return FederationInstance;
+    } else {
+        // Merge options
+        instance.initOptions(options);
+        return instance;
+    }
+}
+function loadRemote(...args) {
+    share.assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadRemote.apply(FederationInstance, args);
+}
+function loadShare(...args) {
+    share.assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadShare.apply(FederationInstance, args);
+}
+function loadShareSync(...args) {
+    share.assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.loadShareSync.apply(FederationInstance, args);
+}
+function preloadRemote(...args) {
+    share.assert(FederationInstance, 'Please call init first');
+    // eslint-disable-next-line prefer-spread
+    return FederationInstance.preloadRemote.apply(FederationInstance, args);
+}
+// Inject for debug
+share.setGlobalFederationConstructor(FederationHost);
+
+exports.registerGlobalPlugins = share.registerGlobalPlugins;
+exports.FederationHost = FederationHost;
+exports.init = init;
+exports.loadRemote = loadRemote;
+exports.loadShare = loadShare;
+exports.loadShareSync = loadShareSync;
+exports.preloadRemote = preloadRemote;