@module-federation/runtime-core 0.19.0 → 0.20.0

package/dist/index.esm.js

@@ -1,7 +1,6 @@
-import { _ as _extends, a as _object_without_properties_loose } from './polyfills.esm.js';
 import { createLogger, isBrowserEnv, isReactNativeEnv, isDebugMode, composeKeyWithSeparator, loadScriptNode, loadScript, createLink, createScript, safeToString, getResourceUrl, isManifestProvider, generateSnapshotFromManifest, warn as warn$1 } from '@module-federation/sdk';
 export { loadScript, loadScriptNode } from '@module-federation/sdk';
-import { getShortErrorMsg, RUNTIME_008, runtimeDescMap, RUNTIME_001, RUNTIME_002, RUNTIME_007, RUNTIME_003, RUNTIME_005, RUNTIME_006, RUNTIME_004 } from '@module-federation/error-codes';
+import { RUNTIME_008, getShortErrorMsg, runtimeDescMap, RUNTIME_001, RUNTIME_002, RUNTIME_007, RUNTIME_003, RUNTIME_005, RUNTIME_006, RUNTIME_004 } from '@module-federation/error-codes';
 
 const LOG_CATEGORY = '[ Federation Runtime ]';
 // FIXME: pre-bundle ?
@@ -29,13 +28,14 @@ function warn(msg) {
             msg.message = `${LOG_CATEGORY}: ${msg.message}`;
         }
         logger.warn(msg);
-    } else {
+    }
+    else {
         logger.warn(msg);
     }
 }
 
 function addUniqueItem(arr, item) {
-    if (arr.findIndex((name)=>name === item) === -1) {
+    if (arr.findIndex((name) => name === item) === -1) {
         arr.push(item);
     }
     return arr;
@@ -43,9 +43,11 @@ function addUniqueItem(arr, item) {
 function getFMId(remoteInfo) {
     if ('version' in remoteInfo && remoteInfo.version) {
         return `${remoteInfo.name}:${remoteInfo.version}`;
-    } else if ('entry' in remoteInfo && remoteInfo.entry) {
+    }
+    else if ('entry' in remoteInfo && remoteInfo.entry) {
         return `${remoteInfo.name}:${remoteInfo.entry}`;
-    } else {
+    }
+    else {
         return `${remoteInfo.name}`;
     }
 }
@@ -60,7 +62,8 @@ async function safeWrapper(callback, disableWarn) {
     try {
         const res = await callback();
         return res;
-    } catch (e) {
+    }
+    catch (e) {
         !disableWarn && warn(e);
         return;
     }
@@ -82,38 +85,39 @@ function isStaticResourcesEqual(url1, url2) {
     return relativeUrl1 === relativeUrl2;
 }
 function arrayOptions(options) {
-    return Array.isArray(options) ? options : [
-        options
-    ];
+    return Array.isArray(options) ? options : [options];
 }
 function getRemoteEntryInfoFromSnapshot(snapshot) {
     const defaultRemoteEntryInfo = {
         url: '',
         type: 'global',
-        globalName: ''
+        globalName: '',
     };
     if (isBrowserEnv() || isReactNativeEnv()) {
-        return 'remoteEntry' in snapshot ? {
-            url: snapshot.remoteEntry,
-            type: snapshot.remoteEntryType,
-            globalName: snapshot.globalName
-        } : defaultRemoteEntryInfo;
+        return 'remoteEntry' in snapshot
+            ? {
+                url: snapshot.remoteEntry,
+                type: snapshot.remoteEntryType,
+                globalName: snapshot.globalName,
+            }
+            : defaultRemoteEntryInfo;
     }
     if ('ssrRemoteEntry' in snapshot) {
         return {
             url: snapshot.ssrRemoteEntry || defaultRemoteEntryInfo.url,
             type: snapshot.ssrRemoteEntryType || defaultRemoteEntryInfo.type,
-            globalName: snapshot.globalName
+            globalName: snapshot.globalName,
         };
     }
     return defaultRemoteEntryInfo;
 }
-const processModuleAlias = (name, subPath)=>{
+const processModuleAlias = (name, subPath) => {
     // @host/ ./button -> @host/button
     let moduleName;
     if (name.endsWith('/')) {
         moduleName = name.slice(0, -1);
-    } else {
+    }
+    else {
         moduleName = name;
     }
     if (subPath.startsWith('.')) {
@@ -124,11 +128,12 @@ const processModuleAlias = (name, subPath)=>{
 };
 
 const CurrentGlobal = typeof globalThis === 'object' ? globalThis : window;
-const nativeGlobal = (()=>{
+const nativeGlobal = (() => {
     try {
         // get real window (incase of sandbox)
         return document.defaultView;
-    } catch (e) {
+    }
+    catch {
         // node env
         return CurrentGlobal;
     }
@@ -138,7 +143,7 @@ function definePropertyGlobalVal(target, key, val) {
     Object.defineProperty(target, key, {
         value: val,
         configurable: false,
-        writable: true
+        writable: true,
     });
 }
 function includeOwnProperty(target, key) {
@@ -152,8 +157,8 @@ if (!includeOwnProperty(CurrentGlobal, '__GLOBAL_LOADING_REMOTE_ENTRY__')) {
 }
 const globalLoading = CurrentGlobal.__GLOBAL_LOADING_REMOTE_ENTRY__;
 function setGlobalDefaultVal(target) {
-    var _target___FEDERATION__, _target___FEDERATION__1, _target___FEDERATION__2, _target___FEDERATION__3, _target___FEDERATION__4, _target___FEDERATION__5;
-    if (includeOwnProperty(target, '__VMOK__') && !includeOwnProperty(target, '__FEDERATION__')) {
+    if (includeOwnProperty(target, '__VMOK__') &&
+        !includeOwnProperty(target, '__FEDERATION__')) {
         definePropertyGlobalVal(target, '__FEDERATION__', target.__VMOK__);
     }
     if (!includeOwnProperty(target, '__FEDERATION__')) {
@@ -163,22 +168,16 @@ function setGlobalDefaultVal(target) {
             moduleInfo: {},
             __SHARE__: {},
             __MANIFEST_LOADING__: {},
-            __PRELOADED_MAP__: new Map()
+            __PRELOADED_MAP__: new Map(),
         });
         definePropertyGlobalVal(target, '__VMOK__', target.__FEDERATION__);
     }
-    var ___GLOBAL_PLUGIN__;
-    (___GLOBAL_PLUGIN__ = (_target___FEDERATION__ = target.__FEDERATION__).__GLOBAL_PLUGIN__) != null ? ___GLOBAL_PLUGIN__ : _target___FEDERATION__.__GLOBAL_PLUGIN__ = [];
-    var ___INSTANCES__;
-    (___INSTANCES__ = (_target___FEDERATION__1 = target.__FEDERATION__).__INSTANCES__) != null ? ___INSTANCES__ : _target___FEDERATION__1.__INSTANCES__ = [];
-    var _moduleInfo;
-    (_moduleInfo = (_target___FEDERATION__2 = target.__FEDERATION__).moduleInfo) != null ? _moduleInfo : _target___FEDERATION__2.moduleInfo = {};
-    var ___SHARE__;
-    (___SHARE__ = (_target___FEDERATION__3 = target.__FEDERATION__).__SHARE__) != null ? ___SHARE__ : _target___FEDERATION__3.__SHARE__ = {};
-    var ___MANIFEST_LOADING__;
-    (___MANIFEST_LOADING__ = (_target___FEDERATION__4 = target.__FEDERATION__).__MANIFEST_LOADING__) != null ? ___MANIFEST_LOADING__ : _target___FEDERATION__4.__MANIFEST_LOADING__ = {};
-    var ___PRELOADED_MAP__;
-    (___PRELOADED_MAP__ = (_target___FEDERATION__5 = target.__FEDERATION__).__PRELOADED_MAP__) != null ? ___PRELOADED_MAP__ : _target___FEDERATION__5.__PRELOADED_MAP__ = new Map();
+    target.__FEDERATION__.__GLOBAL_PLUGIN__ ??= [];
+    target.__FEDERATION__.__INSTANCES__ ??= [];
+    target.__FEDERATION__.moduleInfo ??= {};
+    target.__FEDERATION__.__SHARE__ ??= {};
+    target.__FEDERATION__.__MANIFEST_LOADING__ ??= {};
+    target.__FEDERATION__.__PRELOADED_MAP__ ??= new Map();
 }
 setGlobalDefaultVal(CurrentGlobal);
 setGlobalDefaultVal(nativeGlobal);
@@ -188,7 +187,7 @@ function resetFederationGlobalInfo() {
     CurrentGlobal.__FEDERATION__.moduleInfo = {};
     CurrentGlobal.__FEDERATION__.__SHARE__ = {};
     CurrentGlobal.__FEDERATION__.__MANIFEST_LOADING__ = {};
-    Object.keys(globalLoading).forEach((key)=>{
+    Object.keys(globalLoading).forEach((key) => {
         delete globalLoading[key];
     });
 }
@@ -201,7 +200,7 @@ function getGlobalFederationConstructor() {
 function setGlobalFederationConstructor(FederationConstructor, isDebug = isDebugMode()) {
     if (isDebug) {
         CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
-        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.19.0";
+        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.20.0";
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -211,37 +210,42 @@ function getInfoWithoutType(target, key) {
         if (keyRes) {
             return {
                 value: target[key],
-                key: key
+                key: key,
             };
-        } else {
+        }
+        else {
             const targetKeys = Object.keys(target);
-            for (const targetKey of targetKeys){
+            for (const targetKey of targetKeys) {
                 const [targetTypeOrName, _] = targetKey.split(':');
                 const nKey = `${targetTypeOrName}:${key}`;
                 const typeWithKeyRes = target[nKey];
                 if (typeWithKeyRes) {
                     return {
                         value: typeWithKeyRes,
-                        key: nKey
+                        key: nKey,
                     };
                 }
             }
             return {
                 value: undefined,
-                key: key
+                key: key,
             };
         }
-    } else {
+    }
+    else {
         throw new Error('key must be string');
     }
 }
-const getGlobalSnapshot = ()=>nativeGlobal.__FEDERATION__.moduleInfo;
-const getTargetSnapshotInfoByModuleInfo = (moduleInfo, snapshot)=>{
+const getGlobalSnapshot = () => nativeGlobal.__FEDERATION__.moduleInfo;
+const getTargetSnapshotInfoByModuleInfo = (moduleInfo, snapshot) => {
     // Check if the remote is included in the hostSnapshot
     const moduleKey = getFMId(moduleInfo);
     const getModuleInfo = getInfoWithoutType(snapshot, moduleKey).value;
     // The remoteSnapshot might not include a version
-    if (getModuleInfo && !getModuleInfo.version && 'version' in moduleInfo && moduleInfo['version']) {
+    if (getModuleInfo &&
+        !getModuleInfo.version &&
+        'version' in moduleInfo &&
+        moduleInfo['version']) {
         getModuleInfo.version = moduleInfo['version'];
     }
     if (getModuleInfo) {
@@ -249,57 +253,59 @@ const getTargetSnapshotInfoByModuleInfo = (moduleInfo, snapshot)=>{
     }
     // If the remote is not included in the hostSnapshot, deploy a micro app snapshot
     if ('version' in moduleInfo && moduleInfo['version']) {
-        const { version } = moduleInfo, resModuleInfo = _object_without_properties_loose(moduleInfo, [
-            "version"
-        ]);
+        const { version, ...resModuleInfo } = moduleInfo;
         const moduleKeyWithoutVersion = getFMId(resModuleInfo);
         const getModuleInfoWithoutVersion = getInfoWithoutType(nativeGlobal.__FEDERATION__.moduleInfo, moduleKeyWithoutVersion).value;
-        if ((getModuleInfoWithoutVersion == null ? void 0 : getModuleInfoWithoutVersion.version) === version) {
+        if (getModuleInfoWithoutVersion?.version === version) {
             return getModuleInfoWithoutVersion;
         }
     }
     return;
 };
-const getGlobalSnapshotInfoByModuleInfo = (moduleInfo)=>getTargetSnapshotInfoByModuleInfo(moduleInfo, nativeGlobal.__FEDERATION__.moduleInfo);
-const setGlobalSnapshotInfoByModuleInfo = (remoteInfo, moduleDetailInfo)=>{
+const getGlobalSnapshotInfoByModuleInfo = (moduleInfo) => getTargetSnapshotInfoByModuleInfo(moduleInfo, nativeGlobal.__FEDERATION__.moduleInfo);
+const setGlobalSnapshotInfoByModuleInfo = (remoteInfo, moduleDetailInfo) => {
     const moduleKey = getFMId(remoteInfo);
     nativeGlobal.__FEDERATION__.moduleInfo[moduleKey] = moduleDetailInfo;
     return nativeGlobal.__FEDERATION__.moduleInfo;
 };
-const addGlobalSnapshot = (moduleInfos)=>{
-    nativeGlobal.__FEDERATION__.moduleInfo = _extends({}, nativeGlobal.__FEDERATION__.moduleInfo, moduleInfos);
-    return ()=>{
+const addGlobalSnapshot = (moduleInfos) => {
+    nativeGlobal.__FEDERATION__.moduleInfo = {
+        ...nativeGlobal.__FEDERATION__.moduleInfo,
+        ...moduleInfos,
+    };
+    return () => {
         const keys = Object.keys(moduleInfos);
-        for (const key of keys){
+        for (const key of keys) {
             delete nativeGlobal.__FEDERATION__.moduleInfo[key];
         }
     };
 };
-const getRemoteEntryExports = (name, globalName)=>{
+const getRemoteEntryExports = (name, globalName) => {
     const remoteEntryKey = globalName || `__FEDERATION_${name}:custom__`;
     const entryExports = CurrentGlobal[remoteEntryKey];
     return {
         remoteEntryKey,
-        entryExports
+        entryExports,
     };
 };
 // This function is used to register global plugins.
 // It iterates over the provided plugins and checks if they are already registered.
 // If a plugin is not registered, it is added to the global plugins.
 // If a plugin is already registered, a warning message is logged.
-const registerGlobalPlugins = (plugins)=>{
+const registerGlobalPlugins = (plugins) => {
     const { __GLOBAL_PLUGIN__ } = nativeGlobal.__FEDERATION__;
-    plugins.forEach((plugin)=>{
-        if (__GLOBAL_PLUGIN__.findIndex((p)=>p.name === plugin.name) === -1) {
+    plugins.forEach((plugin) => {
+        if (__GLOBAL_PLUGIN__.findIndex((p) => p.name === plugin.name) === -1) {
             __GLOBAL_PLUGIN__.push(plugin);
-        } else {
+        }
+        else {
             warn(`The plugin ${plugin.name} has been registered.`);
         }
     });
 };
-const getGlobalHostPlugins = ()=>nativeGlobal.__FEDERATION__.__GLOBAL_PLUGIN__;
-const getPreloaded = (id)=>CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.get(id);
-const setPreloaded = (id)=>CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
+const getGlobalHostPlugins = () => nativeGlobal.__FEDERATION__.__GLOBAL_PLUGIN__;
+const getPreloaded = (id) => CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.get(id);
+const setPreloaded = (id) => CurrentGlobal.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
 
 const DEFAULT_SCOPE = 'default';
 const DEFAULT_REMOTE_TYPE = 'global';
@@ -358,7 +364,7 @@ function isXVersion(version) {
     return !version || version.toLowerCase() === 'x' || version === '*';
 }
 function pipe(...fns) {
-    return (x)=>fns.reduce((v, f)=>f(v), x);
+    return (x) => fns.reduce((v, f) => f(v), x);
 }
 function extractComparator(comparatorString) {
     return comparatorString.match(parseRegex(comparator));
@@ -380,25 +386,32 @@ function combineVersion(major, minor, patch, preRelease) {
 // THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 function parseHyphen(range) {
-    return range.replace(parseRegex(hyphenRange), (_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease)=>{
+    return range.replace(parseRegex(hyphenRange), (_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease) => {
         if (isXVersion(fromMajor)) {
             from = '';
-        } else if (isXVersion(fromMinor)) {
+        }
+        else if (isXVersion(fromMinor)) {
             from = `>=${fromMajor}.0.0`;
-        } else if (isXVersion(fromPatch)) {
+        }
+        else if (isXVersion(fromPatch)) {
             from = `>=${fromMajor}.${fromMinor}.0`;
-        } else {
+        }
+        else {
             from = `>=${from}`;
         }
         if (isXVersion(toMajor)) {
             to = '';
-        } else if (isXVersion(toMinor)) {
+        }
+        else if (isXVersion(toMinor)) {
             to = `<${Number(toMajor) + 1}.0.0-0`;
-        } else if (isXVersion(toPatch)) {
+        }
+        else if (isXVersion(toPatch)) {
             to = `<${toMajor}.${Number(toMinor) + 1}.0-0`;
-        } else if (toPreRelease) {
+        }
+        else if (toPreRelease) {
             to = `<=${toMajor}.${toMinor}.${toPatch}-${toPreRelease}`;
-        } else {
+        }
+        else {
             to = `<=${to}`;
         }
         return `${from} ${to}`.trim();
@@ -414,109 +427,140 @@ function parseCaretTrim(range) {
     return range.replace(parseRegex(caretTrim), '$1^');
 }
 function parseCarets(range) {
-    return range.trim().split(/\s+/).map((rangeVersion)=>rangeVersion.replace(parseRegex(caret), (_, major, minor, patch, preRelease)=>{
-            if (isXVersion(major)) {
-                return '';
-            } else if (isXVersion(minor)) {
-                return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
-            } else if (isXVersion(patch)) {
-                if (major === '0') {
-                    return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
-                } else {
-                    return `>=${major}.${minor}.0 <${Number(major) + 1}.0.0-0`;
+    return range
+        .trim()
+        .split(/\s+/)
+        .map((rangeVersion) => rangeVersion.replace(parseRegex(caret), (_, major, minor, patch, preRelease) => {
+        if (isXVersion(major)) {
+            return '';
+        }
+        else if (isXVersion(minor)) {
+            return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
+        }
+        else if (isXVersion(patch)) {
+            if (major === '0') {
+                return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
+            }
+            else {
+                return `>=${major}.${minor}.0 <${Number(major) + 1}.0.0-0`;
+            }
+        }
+        else if (preRelease) {
+            if (major === '0') {
+                if (minor === '0') {
+                    return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${minor}.${Number(patch) + 1}-0`;
                 }
-            } else if (preRelease) {
-                if (major === '0') {
-                    if (minor === '0') {
-                        return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${minor}.${Number(patch) + 1}-0`;
-                    } else {
-                        return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
-                    }
-                } else {
-                    return `>=${major}.${minor}.${patch}-${preRelease} <${Number(major) + 1}.0.0-0`;
+                else {
+                    return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
                 }
-            } else {
-                if (major === '0') {
-                    if (minor === '0') {
-                        return `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}-0`;
-                    } else {
-                        return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
-                    }
+            }
+            else {
+                return `>=${major}.${minor}.${patch}-${preRelease} <${Number(major) + 1}.0.0-0`;
+            }
+        }
+        else {
+            if (major === '0') {
+                if (minor === '0') {
+                    return `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}-0`;
+                }
+                else {
+                    return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
                 }
-                return `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0-0`;
             }
-        })).join(' ');
+            return `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0-0`;
+        }
+    }))
+        .join(' ');
 }
 function parseTildes(range) {
-    return range.trim().split(/\s+/).map((rangeVersion)=>rangeVersion.replace(parseRegex(tilde), (_, major, minor, patch, preRelease)=>{
-            if (isXVersion(major)) {
-                return '';
-            } else if (isXVersion(minor)) {
-                return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
-            } else if (isXVersion(patch)) {
-                return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
-            } else if (preRelease) {
-                return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
-            }
-            return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
-        })).join(' ');
+    return range
+        .trim()
+        .split(/\s+/)
+        .map((rangeVersion) => rangeVersion.replace(parseRegex(tilde), (_, major, minor, patch, preRelease) => {
+        if (isXVersion(major)) {
+            return '';
+        }
+        else if (isXVersion(minor)) {
+            return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
+        }
+        else if (isXVersion(patch)) {
+            return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
+        }
+        else if (preRelease) {
+            return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+        }
+        return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+    }))
+        .join(' ');
 }
 function parseXRanges(range) {
-    return range.split(/\s+/).map((rangeVersion)=>rangeVersion.trim().replace(parseRegex(xRange), (ret, gtlt, major, minor, patch, preRelease)=>{
-            const isXMajor = isXVersion(major);
-            const isXMinor = isXMajor || isXVersion(minor);
-            const isXPatch = isXMinor || isXVersion(patch);
-            if (gtlt === '=' && isXPatch) {
-                gtlt = '';
-            }
-            preRelease = '';
-            if (isXMajor) {
-                if (gtlt === '>' || gtlt === '<') {
-                    // nothing is allowed
-                    return '<0.0.0-0';
-                } else {
-                    // nothing is forbidden
-                    return '*';
-                }
-            } else if (gtlt && isXPatch) {
-                // replace X with 0
+    return range
+        .split(/\s+/)
+        .map((rangeVersion) => rangeVersion
+        .trim()
+        .replace(parseRegex(xRange), (ret, gtlt, major, minor, patch, preRelease) => {
+        const isXMajor = isXVersion(major);
+        const isXMinor = isXMajor || isXVersion(minor);
+        const isXPatch = isXMinor || isXVersion(patch);
+        if (gtlt === '=' && isXPatch) {
+            gtlt = '';
+        }
+        preRelease = '';
+        if (isXMajor) {
+            if (gtlt === '>' || gtlt === '<') {
+                // nothing is allowed
+                return '<0.0.0-0';
+            }
+            else {
+                // nothing is forbidden
+                return '*';
+            }
+        }
+        else if (gtlt && isXPatch) {
+            // replace X with 0
+            if (isXMinor) {
+                minor = 0;
+            }
+            patch = 0;
+            if (gtlt === '>') {
+                // >1 => >=2.0.0
+                // >1.2 => >=1.3.0
+                gtlt = '>=';
                 if (isXMinor) {
+                    major = Number(major) + 1;
                     minor = 0;
+                    patch = 0;
                 }
-                patch = 0;
-                if (gtlt === '>') {
-                    // >1 => >=2.0.0
-                    // >1.2 => >=1.3.0
-                    gtlt = '>=';
-                    if (isXMinor) {
-                        major = Number(major) + 1;
-                        minor = 0;
-                        patch = 0;
-                    } else {
-                        minor = Number(minor) + 1;
-                        patch = 0;
-                    }
-                } else if (gtlt === '<=') {
-                    // <=0.7.x is actually <0.8.0, since any 0.7.x should pass
-                    // Similarly, <=7.x is actually <8.0.0, etc.
-                    gtlt = '<';
-                    if (isXMinor) {
-                        major = Number(major) + 1;
-                    } else {
-                        minor = Number(minor) + 1;
-                    }
+                else {
+                    minor = Number(minor) + 1;
+                    patch = 0;
                 }
-                if (gtlt === '<') {
-                    preRelease = '-0';
+            }
+            else if (gtlt === '<=') {
+                // <=0.7.x is actually <0.8.0, since any 0.7.x should pass
+                // Similarly, <=7.x is actually <8.0.0, etc.
+                gtlt = '<';
+                if (isXMinor) {
+                    major = Number(major) + 1;
                 }
-                return `${gtlt + major}.${minor}.${patch}${preRelease}`;
-            } else if (isXMinor) {
-                return `>=${major}.0.0${preRelease} <${Number(major) + 1}.0.0-0`;
-            } else if (isXPatch) {
-                return `>=${major}.${minor}.0${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+                else {
+                    minor = Number(minor) + 1;
+                }
+            }
+            if (gtlt === '<') {
+                preRelease = '-0';
             }
-            return ret;
-        })).join(' ');
+            return `${gtlt + major}.${minor}.${patch}${preRelease}`;
+        }
+        else if (isXMinor) {
+            return `>=${major}.0.0${preRelease} <${Number(major) + 1}.0.0-0`;
+        }
+        else if (isXPatch) {
+            return `>=${major}.${minor}.0${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+        }
+        return ret;
+    }))
+        .join(' ');
 }
 function parseStar(range) {
     return range.trim().replace(parseRegex(star), '');
@@ -556,7 +600,7 @@ function comparePreRelease(rangeAtom, versionAtom) {
     if (rangePreRelease === undefined && versionPreRelease === undefined) {
         return 0;
     }
-    for(let i = 0, n = rangePreRelease.length; i <= n; i++){
+    for (let i = 0, n = rangePreRelease.length; i <= n; i++) {
         const rangeElement = rangePreRelease[i];
         const versionElement = versionPreRelease[i];
         if (rangeElement === versionElement) {
@@ -576,29 +620,31 @@ function comparePreRelease(rangeAtom, versionAtom) {
     return 0;
 }
 function compareVersion(rangeAtom, versionAtom) {
-    return compareAtom(rangeAtom.major, versionAtom.major) || compareAtom(rangeAtom.minor, versionAtom.minor) || compareAtom(rangeAtom.patch, versionAtom.patch) || comparePreRelease(rangeAtom, versionAtom);
+    return (compareAtom(rangeAtom.major, versionAtom.major) ||
+        compareAtom(rangeAtom.minor, versionAtom.minor) ||
+        compareAtom(rangeAtom.patch, versionAtom.patch) ||
+        comparePreRelease(rangeAtom, versionAtom));
 }
 function eq(rangeAtom, versionAtom) {
     return rangeAtom.version === versionAtom.version;
 }
 function compare(rangeAtom, versionAtom) {
-    switch(rangeAtom.operator){
+    switch (rangeAtom.operator) {
         case '':
         case '=':
             return eq(rangeAtom, versionAtom);
         case '>':
             return compareVersion(rangeAtom, versionAtom) < 0;
         case '>=':
-            return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0;
+            return (eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0);
         case '<':
             return compareVersion(rangeAtom, versionAtom) > 0;
         case '<=':
-            return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0;
-        case undefined:
-            {
-                // mean * or x -> all versions
-                return true;
-            }
+            return (eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0);
+        case undefined: {
+            // mean * or x -> all versions
+            return true;
+        }
         default:
             return false;
     }
@@ -613,14 +659,16 @@ function compare(rangeAtom, versionAtom) {
 // THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 function parseComparatorString(range) {
-    return pipe(// handle caret
+    return pipe(
+    // handle caret
     // ^ --> * (any, kinda silly)
     // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
     // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
     // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
     // ^1.2.3 --> >=1.2.3 <2.0.0-0
     // ^1.2.0 --> >=1.2.0 <2.0.0-0
-    parseCarets, // handle tilde
+    parseCarets, 
+    // handle tilde
     // ~, ~> --> * (any, kinda silly)
     // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
     // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
@@ -630,15 +678,21 @@ function parseComparatorString(range) {
     parseTildes, parseXRanges, parseStar)(range);
 }
 function parseRange(range) {
-    return pipe(// handle hyphenRange
+    return pipe(
+    // handle hyphenRange
     // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-    parseHyphen, // handle trim comparator
+    parseHyphen, 
+    // handle trim comparator
     // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-    parseComparatorTrim, // handle trim tilde
+    parseComparatorTrim, 
+    // handle trim tilde
     // `~ 1.2.3` => `~1.2.3`
-    parseTildeTrim, // handle trim caret
+    parseTildeTrim, 
+    // handle trim caret
     // `^ 1.2.3` => `^1.2.3`
-    parseCaretTrim)(range.trim()).split(/\s+/).join(' ');
+    parseCaretTrim)(range.trim())
+        .split(/\s+/)
+        .join(' ');
 }
 function satisfy(version, range) {
     if (!version) {
@@ -650,18 +704,18 @@ function satisfy(version, range) {
         // If the version string is invalid, it can't satisfy any range
         return false;
     }
-    const [, versionOperator, , versionMajor, versionMinor, versionPatch, versionPreRelease] = extractedVersion;
+    const [, versionOperator, , versionMajor, versionMinor, versionPatch, versionPreRelease,] = extractedVersion;
     const versionAtom = {
         operator: versionOperator,
-        version: combineVersion(versionMajor, versionMinor, versionPatch, versionPreRelease),
+        version: combineVersion(versionMajor, versionMinor, versionPatch, versionPreRelease), // exclude build atom
         major: versionMajor,
         minor: versionMinor,
         patch: versionPatch,
-        preRelease: versionPreRelease == null ? void 0 : versionPreRelease.split('.')
+        preRelease: versionPreRelease?.split('.'),
     };
     // Split the range by || to handle OR conditions
     const orRanges = range.split('||');
-    for (const orRange of orRanges){
+    for (const orRange of orRanges) {
         const trimmedOrRange = orRange.trim();
         if (!trimmedOrRange) {
             // An empty range string signifies wildcard *, satisfy any valid version
@@ -682,36 +736,41 @@ function satisfy(version, range) {
                 // If parsing results in empty string, treat as wildcard match
                 return true;
             }
-            const parsedComparatorString = parsedSubRange.split(' ').map((rangeVersion)=>parseComparatorString(rangeVersion)) // Expands ^, ~
-            .join(' ');
+            const parsedComparatorString = parsedSubRange
+                .split(' ')
+                .map((rangeVersion) => parseComparatorString(rangeVersion)) // Expands ^, ~
+                .join(' ');
             // Check again if the comparator string became empty after specific parsing like ^ or ~
             if (!parsedComparatorString.trim()) {
                 return true;
             }
             // Split the sub-range by space for implicit AND conditions
-            const comparators = parsedComparatorString.split(/\s+/).map((comparator)=>parseGTE0(comparator))// Filter out empty strings that might result from multiple spaces
-            .filter(Boolean);
+            const comparators = parsedComparatorString
+                .split(/\s+/)
+                .map((comparator) => parseGTE0(comparator))
+                // Filter out empty strings that might result from multiple spaces
+                .filter(Boolean);
             // If a sub-range becomes empty after parsing (e.g., invalid characters),
             // it cannot be satisfied. This check might be redundant now but kept for safety.
             if (comparators.length === 0) {
                 continue;
             }
             let subRangeSatisfied = true;
-            for (const comparator of comparators){
+            for (const comparator of comparators) {
                 const extractedComparator = extractComparator(comparator);
                 // If any part of the AND sub-range is invalid, the sub-range is not satisfied
                 if (!extractedComparator) {
                     subRangeSatisfied = false;
                     break;
                 }
-                const [, rangeOperator, , rangeMajor, rangeMinor, rangePatch, rangePreRelease] = extractedComparator;
+                const [, rangeOperator, , rangeMajor, rangeMinor, rangePatch, rangePreRelease,] = extractedComparator;
                 const rangeAtom = {
                     operator: rangeOperator,
                     version: combineVersion(rangeMajor, rangeMinor, rangePatch, rangePreRelease),
                     major: rangeMajor,
                     minor: rangeMinor,
                     patch: rangePatch,
-                    preRelease: rangePreRelease == null ? void 0 : rangePreRelease.split('.')
+                    preRelease: rangePreRelease?.split('.'),
                 };
                 // Check if the version satisfies this specific comparator in the AND chain
                 if (!compare(rangeAtom, versionAtom)) {
@@ -723,7 +782,8 @@ function satisfy(version, range) {
             if (subRangeSatisfied) {
                 return true;
             }
-        } catch (e) {
+        }
+        catch (e) {
             // Log error and treat this sub-range as unsatisfied
             console.error(`[semver] Error processing range part "${trimmedOrRange}":`, e);
             continue;
@@ -738,71 +798,73 @@ function formatShare(shareArgs, from, name, shareStrategy) {
     if ('get' in shareArgs) {
         // eslint-disable-next-line prefer-destructuring
         get = shareArgs.get;
-    } else if ('lib' in shareArgs) {
-        get = ()=>Promise.resolve(shareArgs.lib);
-    } else {
-        get = ()=>Promise.resolve(()=>{
-                throw new Error(`Can not get shared '${name}'!`);
-            });
     }
-    var _shareArgs_version, _shareArgs_scope, _shareArgs_strategy;
-    return _extends({
+    else if ('lib' in shareArgs) {
+        get = () => Promise.resolve(shareArgs.lib);
+    }
+    else {
+        get = () => Promise.resolve(() => {
+            throw new Error(`Can not get shared '${name}'!`);
+        });
+    }
+    return {
         deps: [],
         useIn: [],
         from,
-        loading: null
-    }, shareArgs, {
-        shareConfig: _extends({
+        loading: null,
+        ...shareArgs,
+        shareConfig: {
             requiredVersion: `^${shareArgs.version}`,
             singleton: false,
             eager: false,
-            strictVersion: false
-        }, shareArgs.shareConfig),
+            strictVersion: false,
+            ...shareArgs.shareConfig,
+        },
         get,
-        loaded: (shareArgs == null ? void 0 : shareArgs.loaded) || 'lib' in shareArgs ? true : undefined,
-        version: (_shareArgs_version = shareArgs.version) != null ? _shareArgs_version : '0',
-        scope: Array.isArray(shareArgs.scope) ? shareArgs.scope : [
-            (_shareArgs_scope = shareArgs.scope) != null ? _shareArgs_scope : 'default'
-        ],
-        strategy: ((_shareArgs_strategy = shareArgs.strategy) != null ? _shareArgs_strategy : shareStrategy) || 'version-first'
-    });
+        loaded: shareArgs?.loaded || 'lib' in shareArgs ? true : undefined,
+        version: shareArgs.version ?? '0',
+        scope: Array.isArray(shareArgs.scope)
+            ? shareArgs.scope
+            : [shareArgs.scope ?? 'default'],
+        strategy: (shareArgs.strategy ?? shareStrategy) || 'version-first',
+    };
 }
 function formatShareConfigs(globalOptions, userOptions) {
     const shareArgs = userOptions.shared || {};
     const from = userOptions.name;
-    const shareInfos = Object.keys(shareArgs).reduce((res, pkgName)=>{
+    const shareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
         const arrayShareArgs = arrayOptions(shareArgs[pkgName]);
         res[pkgName] = res[pkgName] || [];
-        arrayShareArgs.forEach((shareConfig)=>{
+        arrayShareArgs.forEach((shareConfig) => {
             res[pkgName].push(formatShare(shareConfig, from, pkgName, userOptions.shareStrategy));
         });
         return res;
     }, {});
-    const shared = _extends({}, globalOptions.shared);
-    Object.keys(shareInfos).forEach((shareKey)=>{
+    const shared = {
+        ...globalOptions.shared,
+    };
+    Object.keys(shareInfos).forEach((shareKey) => {
         if (!shared[shareKey]) {
             shared[shareKey] = shareInfos[shareKey];
-        } else {
-            shareInfos[shareKey].forEach((newUserSharedOptions)=>{
-                const isSameVersion = shared[shareKey].find((sharedVal)=>sharedVal.version === newUserSharedOptions.version);
+        }
+        else {
+            shareInfos[shareKey].forEach((newUserSharedOptions) => {
+                const isSameVersion = shared[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
                 if (!isSameVersion) {
                     shared[shareKey].push(newUserSharedOptions);
                 }
             });
         }
     });
-    return {
-        shared,
-        shareInfos
-    };
+    return { shared, shareInfos };
 }
 function versionLt(a, b) {
-    const transformInvalidVersion = (version)=>{
+    const transformInvalidVersion = (version) => {
         const isNumberVersion = !Number.isNaN(Number(version));
         if (isNumberVersion) {
             const splitArr = version.split('.');
             let validVersion = version;
-            for(let i = 0; i < 3 - splitArr.length; i++){
+            for (let i = 0; i < 3 - splitArr.length; i++) {
                 validVersion += '.0';
             }
             return validVersion;
@@ -811,15 +873,17 @@ function versionLt(a, b) {
     };
     if (satisfy(transformInvalidVersion(a), `<=${transformInvalidVersion(b)}`)) {
         return true;
-    } else {
+    }
+    else {
         return false;
     }
 }
-const findVersion = (shareVersionMap, cb)=>{
-    const callback = cb || function(prev, cur) {
-        return versionLt(prev, cur);
-    };
-    return Object.keys(shareVersionMap).reduce((prev, cur)=>{
+const findVersion = (shareVersionMap, cb) => {
+    const callback = cb ||
+        function (prev, cur) {
+            return versionLt(prev, cur);
+        };
+    return Object.keys(shareVersionMap).reduce((prev, cur) => {
         if (!prev) {
             return cur;
         }
@@ -833,29 +897,30 @@ const findVersion = (shareVersionMap, cb)=>{
         return prev;
     }, 0);
 };
-const isLoaded = (shared)=>{
+const isLoaded = (shared) => {
     return Boolean(shared.loaded) || typeof shared.lib === 'function';
 };
-const isLoading = (shared)=>{
+const isLoading = (shared) => {
     return Boolean(shared.loading);
 };
 function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName) {
     const versions = shareScopeMap[scope][pkgName];
-    const callback = function(prev, cur) {
+    const callback = function (prev, cur) {
         return !isLoaded(versions[prev]) && versionLt(prev, cur);
     };
     return findVersion(shareScopeMap[scope][pkgName], callback);
 }
 function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
     const versions = shareScopeMap[scope][pkgName];
-    const callback = function(prev, cur) {
-        const isLoadingOrLoaded = (shared)=>{
+    const callback = function (prev, cur) {
+        const isLoadingOrLoaded = (shared) => {
             return isLoaded(shared) || isLoading(shared);
         };
         if (isLoadingOrLoaded(versions[cur])) {
             if (isLoadingOrLoaded(versions[prev])) {
                 return Boolean(versionLt(prev, cur));
-            } else {
+            }
+            else {
                 return true;
             }
         }
@@ -877,34 +942,38 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
         return;
     }
     const { shareConfig, scope = DEFAULT_SCOPE, strategy } = shareInfo;
-    const scopes = Array.isArray(scope) ? scope : [
-        scope
-    ];
-    for (const sc of scopes){
-        if (shareConfig && localShareScopeMap[sc] && localShareScopeMap[sc][pkgName]) {
+    const scopes = Array.isArray(scope) ? scope : [scope];
+    for (const sc of scopes) {
+        if (shareConfig &&
+            localShareScopeMap[sc] &&
+            localShareScopeMap[sc][pkgName]) {
             const { requiredVersion } = shareConfig;
             const findShareFunction = getFindShareFunction(strategy);
             const maxOrSingletonVersion = findShareFunction(localShareScopeMap, sc, pkgName);
             //@ts-ignore
-            const defaultResolver = ()=>{
+            const defaultResolver = () => {
                 if (shareConfig.singleton) {
-                    if (typeof requiredVersion === 'string' && !satisfy(maxOrSingletonVersion, requiredVersion)) {
-                        const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion && localShareScopeMap[sc][pkgName][maxOrSingletonVersion].from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
+                    if (typeof requiredVersion === 'string' &&
+                        !satisfy(maxOrSingletonVersion, requiredVersion)) {
+                        const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion &&
+                            localShareScopeMap[sc][pkgName][maxOrSingletonVersion].from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
                         if (shareConfig.strictVersion) {
                             error(msg);
-                        } else {
+                        }
+                        else {
                             warn(msg);
                         }
                     }
                     return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
-                } else {
+                }
+                else {
                     if (requiredVersion === false || requiredVersion === '*') {
                         return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                     }
                     if (satisfy(maxOrSingletonVersion, requiredVersion)) {
                         return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                     }
-                    for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])){
+                    for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
                         if (satisfy(versionKey, requiredVersion)) {
                             return versionValue;
                         }
@@ -917,7 +986,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                 pkgName,
                 version: maxOrSingletonVersion,
                 GlobalFederation: Global.__FEDERATION__,
-                resolver: defaultResolver
+                resolver: defaultResolver,
             };
             const resolveShared = resolveShare.emit(params) || params;
             return resolveShared.resolver();
@@ -929,28 +998,30 @@ function getGlobalShareScope() {
 }
 function getTargetSharedOptions(options) {
     const { pkgName, extraOptions, shareInfos } = options;
-    const defaultResolver = (sharedOptions)=>{
+    const defaultResolver = (sharedOptions) => {
         if (!sharedOptions) {
             return undefined;
         }
         const shareVersionMap = {};
-        sharedOptions.forEach((shared)=>{
+        sharedOptions.forEach((shared) => {
             shareVersionMap[shared.version] = shared;
         });
-        const callback = function(prev, cur) {
+        const callback = function (prev, cur) {
             return !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur);
         };
         const maxVersion = findVersion(shareVersionMap, callback);
         return shareVersionMap[maxVersion];
     };
-    var _extraOptions_resolver;
-    const resolver = (_extraOptions_resolver = extraOptions == null ? void 0 : extraOptions.resolver) != null ? _extraOptions_resolver : defaultResolver;
-    return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions == null ? void 0 : extraOptions.customShareInfo);
+    const resolver = extraOptions?.resolver ?? defaultResolver;
+    return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions?.customShareInfo);
 }
 
 function getBuilderId() {
     //@ts-ignore
-    return typeof FEDERATION_BUILD_IDENTIFIER !== 'undefined' ? FEDERATION_BUILD_IDENTIFIER : '';
+    return typeof FEDERATION_BUILD_IDENTIFIER !== 'undefined'
+        ? //@ts-ignore
+            FEDERATION_BUILD_IDENTIFIER
+        : '';
 }
 
 // Function to match a remote with its name and expose
@@ -958,7 +1029,7 @@ function getBuilderId() {
 // 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){
+    for (const remote of remotes) {
         // match pkgName
         const isNameMatched = id.startsWith(remote.name);
         let expose = id.replace(remote.name, '');
@@ -969,13 +1040,14 @@ function matchRemoteWithNameAndExpose(remotes, id) {
                 return {
                     pkgNameOrAlias,
                     expose,
-                    remote
+                    remote,
                 };
-            } else if (expose === '') {
+            }
+            else if (expose === '') {
                 return {
                     pkgNameOrAlias: remote.name,
                     expose: '.',
-                    remote
+                    remote,
                 };
             }
         }
@@ -989,13 +1061,14 @@ function matchRemoteWithNameAndExpose(remotes, id) {
                 return {
                     pkgNameOrAlias,
                     expose: exposeWithAlias,
-                    remote
+                    remote,
                 };
-            } else if (exposeWithAlias === '') {
+            }
+            else if (exposeWithAlias === '') {
                 return {
                     pkgNameOrAlias: remote.alias,
                     expose: '.',
-                    remote
+                    remote,
                 };
             }
         }
@@ -1004,7 +1077,7 @@ function matchRemoteWithNameAndExpose(remotes, id) {
 }
 // Function to match a remote with its name or alias
 function matchRemote(remotes, nameOrAlias) {
-    for (const remote of remotes){
+    for (const remote of remotes) {
         const isNameMatched = nameOrAlias === remote.name;
         if (isNameMatched) {
             return remote;
@@ -1025,19 +1098,19 @@ function registerPlugins(plugins, instance) {
         instance.sharedHandler.hooks,
         instance.snapshotHandler.hooks,
         instance.loaderHook,
-        instance.bridgeHook
+        instance.bridgeHook,
     ];
     // Incorporate global plugins
     if (globalPlugins.length > 0) {
-        globalPlugins.forEach((plugin)=>{
-            if (plugins == null ? void 0 : plugins.find((item)=>item.name !== plugin.name)) {
+        globalPlugins.forEach((plugin) => {
+            if (plugins?.find((item) => item.name !== plugin.name)) {
                 plugins.push(plugin);
             }
         });
     }
     if (plugins && plugins.length > 0) {
-        plugins.forEach((plugin)=>{
-            hookInstances.forEach((hookInstance)=>{
+        plugins.forEach((plugin) => {
+            hookInstances.forEach((hookInstance) => {
                 hookInstance.applyPlugin(plugin, instance);
             });
         });
@@ -1046,44 +1119,49 @@ function registerPlugins(plugins, instance) {
 }
 
 const importCallback = '.then(callbacks[0]).catch(callbacks[1])';
-async function loadEsmEntry({ entry, remoteEntryExports }) {
-    return new Promise((resolve, reject)=>{
+async function loadEsmEntry({ entry, remoteEntryExports, }) {
+    return new Promise((resolve, reject) => {
         try {
             if (!remoteEntryExports) {
                 if (typeof FEDERATION_ALLOW_NEW_FUNCTION !== 'undefined') {
                     new Function('callbacks', `import("${entry}")${importCallback}`)([
                         resolve,
-                        reject
+                        reject,
                     ]);
-                } else {
-                    import(/* webpackIgnore: true */ /* @vite-ignore */ entry).then(resolve).catch(reject);
                 }
-            } else {
+                else {
+                    import(/* webpackIgnore: true */ /* @vite-ignore */ entry)
+                        .then(resolve)
+                        .catch(reject);
+                }
+            }
+            else {
                 resolve(remoteEntryExports);
             }
-        } catch (e) {
+        }
+        catch (e) {
             reject(e);
         }
     });
 }
-async function loadSystemJsEntry({ entry, remoteEntryExports }) {
-    return new Promise((resolve, reject)=>{
+async function loadSystemJsEntry({ entry, remoteEntryExports, }) {
+    return new Promise((resolve, reject) => {
         try {
             if (!remoteEntryExports) {
                 //@ts-ignore
                 if (typeof __system_context__ === 'undefined') {
                     //@ts-ignore
                     System.import(entry).then(resolve).catch(reject);
-                } else {
-                    new Function('callbacks', `System.import("${entry}")${importCallback}`)([
-                        resolve,
-                        reject
-                    ]);
                 }
-            } else {
+                else {
+                    new Function('callbacks', `System.import("${entry}")${importCallback}`)([resolve, reject]);
+                }
+            }
+            else {
                 resolve(remoteEntryExports);
             }
-        } catch (e) {
+        }
+        catch (e) {
             reject(e);
         }
     });
@@ -1093,11 +1171,11 @@ function handleRemoteEntryLoaded(name, globalName, entry) {
     assert(entryExports, getShortErrorMsg(RUNTIME_001, runtimeDescMap, {
         remoteName: name,
         remoteEntryUrl: entry,
-        remoteEntryKey
+        remoteEntryKey,
     }));
     return entryExports;
 }
-async function loadEntryScript({ name, globalName, entry, loaderHook, getEntryUrl }) {
+async function loadEntryScript({ name, globalName, entry, loaderHook, getEntryUrl, }) {
     const { entryExports: remoteEntryExports } = getRemoteEntryExports(name, globalName);
     if (remoteEntryExports) {
         return remoteEntryExports;
@@ -1106,12 +1184,10 @@ async function loadEntryScript({ name, globalName, entry, loaderHook, getEntryUr
     const url = getEntryUrl ? getEntryUrl(entry) : entry;
     return loadScript(url, {
         attrs: {},
-        createScriptHook: (url, attrs)=>{
-            const res = loaderHook.lifecycle.createScript.emit({
-                url,
-                attrs
-            });
-            if (!res) return;
+        createScriptHook: (url, attrs) => {
+            const res = loaderHook.lifecycle.createScript.emit({ url, attrs });
+            if (!res)
+                return;
             if (res instanceof HTMLScriptElement) {
                 return res;
             }
@@ -1119,69 +1195,61 @@ async function loadEntryScript({ name, globalName, entry, loaderHook, getEntryUr
                 return res;
             }
             return;
-        }
-    }).then(()=>{
+        },
+    })
+        .then(() => {
         return handleRemoteEntryLoaded(name, globalName, entry);
-    }).catch((e)=>{
+    })
+        .catch((e) => {
         assert(undefined, getShortErrorMsg(RUNTIME_008, runtimeDescMap, {
             remoteName: name,
-            resourceUrl: entry
+            resourceUrl: entry,
         }));
         throw e;
     });
 }
-async function loadEntryDom({ remoteInfo, remoteEntryExports, loaderHook, getEntryUrl }) {
+async function loadEntryDom({ remoteInfo, remoteEntryExports, loaderHook, getEntryUrl, }) {
     const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
-    switch(type){
+    switch (type) {
         case 'esm':
         case 'module':
-            return loadEsmEntry({
-                entry,
-                remoteEntryExports
-            });
+            return loadEsmEntry({ entry, remoteEntryExports });
         case 'system':
-            return loadSystemJsEntry({
-                entry,
-                remoteEntryExports
-            });
+            return loadSystemJsEntry({ entry, remoteEntryExports });
         default:
             return loadEntryScript({
                 entry,
                 globalName,
                 name,
                 loaderHook,
-                getEntryUrl
+                getEntryUrl,
             });
     }
 }
-async function loadEntryNode({ remoteInfo, loaderHook }) {
+async function loadEntryNode({ remoteInfo, loaderHook, }) {
     const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
     const { entryExports: remoteEntryExports } = getRemoteEntryExports(name, globalName);
     if (remoteEntryExports) {
         return remoteEntryExports;
     }
     return loadScriptNode(entry, {
-        attrs: {
-            name,
-            globalName,
-            type
-        },
+        attrs: { name, globalName, type },
         loaderHook: {
-            createScriptHook: (url, attrs = {})=>{
-                const res = loaderHook.lifecycle.createScript.emit({
-                    url,
-                    attrs
-                });
-                if (!res) return;
+            createScriptHook: (url, attrs = {}) => {
+                const res = loaderHook.lifecycle.createScript.emit({ url, attrs });
+                if (!res)
+                    return;
                 if ('url' in res) {
                     return res;
                 }
                 return;
-            }
-        }
-    }).then(()=>{
+            },
+        },
+    })
+        .then(() => {
         return handleRemoteEntryLoaded(name, globalName, entry);
-    }).catch((e)=>{
+    })
+        .catch((e) => {
         throw e;
     });
 }
@@ -1190,7 +1258,7 @@ function getRemoteEntryUniqueKey(remoteInfo) {
     return composeKeyWithSeparator(name, entry);
 }
 async function getRemoteEntry(params) {
-    const { origin, remoteEntryExports, remoteInfo, getEntryUrl } = params;
+    const { origin, remoteEntryExports, remoteInfo, getEntryUrl, _inErrorHandling = false, } = params;
     const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
     if (remoteEntryExports) {
         return remoteEntryExports;
@@ -1198,56 +1266,83 @@ async function getRemoteEntry(params) {
     if (!globalLoading[uniqueKey]) {
         const loadEntryHook = origin.remoteHandler.hooks.lifecycle.loadEntry;
         const loaderHook = origin.loaderHook;
-        globalLoading[uniqueKey] = loadEntryHook.emit({
+        globalLoading[uniqueKey] = loadEntryHook
+            .emit({
             loaderHook,
             remoteInfo,
-            remoteEntryExports
-        }).then((res)=>{
+            remoteEntryExports,
+        })
+            .then((res) => {
             if (res) {
                 return res;
             }
             // Use ENV_TARGET if defined, otherwise fallback to isBrowserEnv, must keep this
-            const isWebEnvironment = typeof ENV_TARGET !== 'undefined' ? ENV_TARGET === 'web' : isBrowserEnv();
-            return isWebEnvironment ? loadEntryDom({
-                remoteInfo,
-                remoteEntryExports,
-                loaderHook,
-                getEntryUrl
-            }) : loadEntryNode({
-                remoteInfo,
-                loaderHook
-            });
+            const isWebEnvironment = typeof ENV_TARGET !== 'undefined'
+                ? ENV_TARGET === 'web'
+                : isBrowserEnv();
+            return isWebEnvironment
+                ? loadEntryDom({
+                    remoteInfo,
+                    remoteEntryExports,
+                    loaderHook,
+                    getEntryUrl,
+                })
+                : loadEntryNode({ remoteInfo, loaderHook });
+        })
+            .catch(async (err) => {
+            const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
+            const isScriptLoadError = err instanceof Error && err.message.includes(RUNTIME_008);
+            if (isScriptLoadError && !_inErrorHandling) {
+                const wrappedGetRemoteEntry = (params) => {
+                    return getRemoteEntry({ ...params, _inErrorHandling: true });
+                };
+                const RemoteEntryExports = await origin.loaderHook.lifecycle.loadEntryError.emit({
+                    getRemoteEntry: wrappedGetRemoteEntry,
+                    origin,
+                    remoteInfo: remoteInfo,
+                    remoteEntryExports,
+                    globalLoading,
+                    uniqueKey,
+                });
+                if (RemoteEntryExports) {
+                    return RemoteEntryExports;
+                }
+            }
+            throw err;
         });
     }
     return globalLoading[uniqueKey];
 }
 function getRemoteInfo(remote) {
-    return _extends({}, remote, {
+    return {
+        ...remote,
         entry: 'entry' in remote ? remote.entry : '',
         type: remote.type || DEFAULT_REMOTE_TYPE,
         entryGlobalName: remote.entryGlobalName || remote.name,
-        shareScope: remote.shareScope || DEFAULT_SCOPE
-    });
+        shareScope: remote.shareScope || DEFAULT_SCOPE,
+    };
 }
 
 function defaultPreloadArgs(preloadConfig) {
-    return _extends({
+    return {
         resourceCategory: 'sync',
         share: true,
         depsRemote: true,
-        prefetchInterface: false
-    }, preloadConfig);
+        prefetchInterface: false,
+        ...preloadConfig,
+    };
 }
 function formatPreloadArgs(remotes, preloadArgs) {
-    return preloadArgs.map((args)=>{
+    return preloadArgs.map((args) => {
         const remoteInfo = matchRemote(remotes, args.nameOrAlias);
-        assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && safeToString({
-            remoteInfo,
-            remotes
-        })}`);
+        assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo &&
+            safeToString({
+                remoteInfo,
+                remotes,
+            })}`);
         return {
             remote: remoteInfo,
-            preloadConfig: defaultPreloadArgs(args)
+            preloadConfig: defaultPreloadArgs(args),
         };
     });
 }
@@ -1255,7 +1350,7 @@ function normalizePreloadExposes(exposes) {
     if (!exposes) {
         return [];
     }
-    return exposes.map((expose)=>{
+    return exposes.map((expose) => {
         if (expose === '.') {
             return expose;
         }
@@ -1265,75 +1360,78 @@ function normalizePreloadExposes(exposes) {
         return expose;
     });
 }
-function preloadAssets(remoteInfo, host, assets, // It is used to distinguish preload from load remote parallel loading
+function preloadAssets(remoteInfo, host, assets, 
+// It is used to distinguish preload from load remote parallel loading
 useLinkPreload = true) {
     const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
     if (host.options.inBrowser) {
-        entryAssets.forEach((asset)=>{
+        entryAssets.forEach((asset) => {
             const { moduleInfo } = asset;
             const module = host.moduleCache.get(remoteInfo.name);
             if (module) {
                 getRemoteEntry({
                     origin: host,
                     remoteInfo: moduleInfo,
-                    remoteEntryExports: module.remoteEntryExports
+                    remoteEntryExports: module.remoteEntryExports,
                 });
-            } else {
+            }
+            else {
                 getRemoteEntry({
                     origin: host,
                     remoteInfo: moduleInfo,
-                    remoteEntryExports: undefined
+                    remoteEntryExports: undefined,
                 });
             }
         });
         if (useLinkPreload) {
             const defaultAttrs = {
                 rel: 'preload',
-                as: 'style'
+                as: 'style',
             };
-            cssAssets.forEach((cssUrl)=>{
+            cssAssets.forEach((cssUrl) => {
                 const { link: cssEl, needAttach } = createLink({
                     url: cssUrl,
-                    cb: ()=>{
-                    // noop
+                    cb: () => {
+                        // noop
                     },
                     attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
+                    createLinkHook: (url, attrs) => {
                         const res = host.loaderHook.lifecycle.createLink.emit({
                             url,
-                            attrs
+                            attrs,
                         });
                         if (res instanceof HTMLLinkElement) {
                             return res;
                         }
                         return;
-                    }
+                    },
                 });
                 needAttach && document.head.appendChild(cssEl);
             });
-        } else {
+        }
+        else {
             const defaultAttrs = {
                 rel: 'stylesheet',
-                type: 'text/css'
+                type: 'text/css',
             };
-            cssAssets.forEach((cssUrl)=>{
+            cssAssets.forEach((cssUrl) => {
                 const { link: cssEl, needAttach } = createLink({
                     url: cssUrl,
-                    cb: ()=>{
-                    // noop
+                    cb: () => {
+                        // noop
                     },
                     attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
+                    createLinkHook: (url, attrs) => {
                         const res = host.loaderHook.lifecycle.createLink.emit({
                             url,
-                            attrs
+                            attrs,
                         });
                         if (res instanceof HTMLLinkElement) {
                             return res;
                         }
                         return;
                     },
-                    needDeleteLink: false
+                    needDeleteLink: false,
                 });
                 needAttach && document.head.appendChild(cssEl);
             });
@@ -1341,51 +1439,52 @@ useLinkPreload = true) {
         if (useLinkPreload) {
             const defaultAttrs = {
                 rel: 'preload',
-                as: 'script'
+                as: 'script',
             };
-            jsAssetsWithoutEntry.forEach((jsUrl)=>{
+            jsAssetsWithoutEntry.forEach((jsUrl) => {
                 const { link: linkEl, needAttach } = createLink({
                     url: jsUrl,
-                    cb: ()=>{
-                    // noop
+                    cb: () => {
+                        // noop
                     },
                     attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
+                    createLinkHook: (url, attrs) => {
                         const res = host.loaderHook.lifecycle.createLink.emit({
                             url,
-                            attrs
+                            attrs,
                         });
                         if (res instanceof HTMLLinkElement) {
                             return res;
                         }
                         return;
-                    }
+                    },
                 });
                 needAttach && document.head.appendChild(linkEl);
             });
-        } else {
+        }
+        else {
             const defaultAttrs = {
                 fetchpriority: 'high',
-                type: (remoteInfo == null ? void 0 : remoteInfo.type) === 'module' ? 'module' : 'text/javascript'
+                type: remoteInfo?.type === 'module' ? 'module' : 'text/javascript',
             };
-            jsAssetsWithoutEntry.forEach((jsUrl)=>{
+            jsAssetsWithoutEntry.forEach((jsUrl) => {
                 const { script: scriptEl, needAttach } = createScript({
                     url: jsUrl,
-                    cb: ()=>{
-                    // noop
+                    cb: () => {
+                        // noop
                     },
                     attrs: defaultAttrs,
-                    createScriptHook: (url, attrs)=>{
+                    createScriptHook: (url, attrs) => {
                         const res = host.loaderHook.lifecycle.createScript.emit({
                             url,
-                            attrs
+                            attrs,
                         });
                         if (res instanceof HTMLScriptElement) {
                             return res;
                         }
                         return;
                     },
-                    needDeleteScript: true
+                    needDeleteScript: true,
                 });
                 needAttach && document.head.appendChild(scriptEl);
             });
@@ -1395,7 +1494,7 @@ useLinkPreload = true) {
 
 const ShareUtils = {
     getRegisteredShare,
-    getGlobalShareScope
+    getGlobalShareScope,
 };
 const GlobalUtils = {
     Global,
@@ -1414,7 +1513,7 @@ const GlobalUtils = {
     registerGlobalPlugins,
     getGlobalHostPlugins,
     getPreloaded,
-    setPreloaded
+    setPreloaded,
 };
 var helpers = {
     global: GlobalUtils,
@@ -1422,56 +1521,45 @@ var helpers = {
     utils: {
         matchRemoteWithNameAndExpose,
         preloadAssets,
-        getRemoteInfo
-    }
+        getRemoteInfo,
+    },
 };
 
-let Module = class Module {
+class Module {
+    constructor({ remoteInfo, host, }) {
+        this.inited = false;
+        this.lib = undefined;
+        this.remoteInfo = remoteInfo;
+        this.host = host;
+    }
     async getEntry() {
         if (this.remoteEntryExports) {
             return this.remoteEntryExports;
         }
         let remoteEntryExports;
-        try {
-            remoteEntryExports = await getRemoteEntry({
-                origin: this.host,
-                remoteInfo: this.remoteInfo,
-                remoteEntryExports: this.remoteEntryExports
-            });
-        } catch (err) {
-            const uniqueKey = getRemoteEntryUniqueKey(this.remoteInfo);
-            const isScriptLoadError = err instanceof Error && err.message.includes(RUNTIME_008);
-            if (isScriptLoadError) {
-                remoteEntryExports = await this.host.loaderHook.lifecycle.loadEntryError.emit({
-                    getRemoteEntry,
-                    origin: this.host,
-                    remoteInfo: this.remoteInfo,
-                    remoteEntryExports: this.remoteEntryExports,
-                    globalLoading,
-                    uniqueKey
-                });
-            }
-        }
+        remoteEntryExports = await getRemoteEntry({
+            origin: this.host,
+            remoteInfo: this.remoteInfo,
+            remoteEntryExports: this.remoteEntryExports,
+        });
         assert(remoteEntryExports, `remoteEntryExports is undefined \n ${safeToString(this.remoteInfo)}`);
         this.remoteEntryExports = remoteEntryExports;
         return this.remoteEntryExports;
     }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     async get(id, expose, options, remoteSnapshot) {
-        const { loadFactory = true } = options || {
-            loadFactory: true
-        };
+        const { loadFactory = true } = options || { loadFactory: true };
         // Get remoteEntry.js
         const remoteEntryExports = await this.getEntry();
         if (!this.inited) {
             const localShareScopeMap = this.host.shareScopeMap;
-            const shareScopeKeys = Array.isArray(this.remoteInfo.shareScope) ? this.remoteInfo.shareScope : [
-                this.remoteInfo.shareScope
-            ];
+            const shareScopeKeys = Array.isArray(this.remoteInfo.shareScope)
+                ? this.remoteInfo.shareScope
+                : [this.remoteInfo.shareScope];
             if (!shareScopeKeys.length) {
                 shareScopeKeys.push('default');
             }
-            shareScopeKeys.forEach((shareScopeKey)=>{
+            shareScopeKeys.forEach((shareScopeKey) => {
                 if (!localShareScopeMap[shareScopeKey]) {
                     localShareScopeMap[shareScopeKey] = {};
                 }
@@ -1481,13 +1569,15 @@ let Module = class Module {
             const initScope = [];
             const remoteEntryInitOptions = {
                 version: this.remoteInfo.version || '',
-                shareScopeKeys: Array.isArray(this.remoteInfo.shareScope) ? shareScopeKeys : this.remoteInfo.shareScope || 'default'
+                shareScopeKeys: Array.isArray(this.remoteInfo.shareScope)
+                    ? shareScopeKeys
+                    : this.remoteInfo.shareScope || 'default',
             };
             // Help to find host instance
             Object.defineProperty(remoteEntryInitOptions, 'shareScopeMap', {
                 value: localShareScopeMap,
                 // remoteEntryInitOptions will be traversed and assigned during container init, ,so this attribute is not allowed to be traversed
-                enumerable: false
+                enumerable: false,
             });
             const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
                 shareScope,
@@ -1495,22 +1585,23 @@ let Module = class Module {
                 remoteEntryInitOptions,
                 initScope,
                 remoteInfo: this.remoteInfo,
-                origin: this.host
+                origin: this.host,
             });
-            if (typeof (remoteEntryExports == null ? void 0 : remoteEntryExports.init) === 'undefined') {
+            if (typeof remoteEntryExports?.init === 'undefined') {
                 error(getShortErrorMsg(RUNTIME_002, runtimeDescMap, {
                     hostName: this.host.name,
                     remoteName: this.remoteInfo.name,
                     remoteEntryUrl: this.remoteInfo.entry,
-                    remoteEntryKey: this.remoteInfo.entryGlobalName
+                    remoteEntryKey: this.remoteInfo.entryGlobalName,
                 }));
             }
             await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
-            await this.host.hooks.lifecycle.initContainer.emit(_extends({}, initContainerOptions, {
+            await this.host.hooks.lifecycle.initContainer.emit({
+                ...initContainerOptions,
                 id,
                 remoteSnapshot,
-                remoteEntryExports
-            }));
+                remoteEntryExports,
+            });
         }
         this.lib = remoteEntryExports;
         this.inited = true;
@@ -1518,7 +1609,7 @@ let Module = class Module {
         moduleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
             remoteEntryExports,
             expose,
-            moduleInfo: this.remoteInfo
+            moduleInfo: this.remoteInfo,
         });
         // get exposeGetter
         if (!moduleFactory) {
@@ -1536,22 +1627,26 @@ let Module = class Module {
     }
     wraperFactory(moduleFactory, id) {
         function defineModuleId(res, id) {
-            if (res && typeof res === 'object' && Object.isExtensible(res) && !Object.getOwnPropertyDescriptor(res, Symbol.for('mf_module_id'))) {
+            if (res &&
+                typeof res === 'object' &&
+                Object.isExtensible(res) &&
+                !Object.getOwnPropertyDescriptor(res, Symbol.for('mf_module_id'))) {
                 Object.defineProperty(res, Symbol.for('mf_module_id'), {
                     value: id,
-                    enumerable: false
+                    enumerable: false,
                 });
             }
         }
         if (moduleFactory instanceof Promise) {
-            return async ()=>{
+            return async () => {
                 const res = await moduleFactory();
                 // This parameter is used for bridge debugging
                 defineModuleId(res, id);
                 return res;
             };
-        } else {
-            return ()=>{
+        }
+        else {
+            return () => {
                 const res = moduleFactory();
                 // This parameter is used for bridge debugging
                 defineModuleId(res, id);
@@ -1559,15 +1654,16 @@ let Module = class Module {
             };
         }
     }
-    constructor({ remoteInfo, host }){
-        this.inited = false;
-        this.lib = undefined;
-        this.remoteInfo = remoteInfo;
-        this.host = host;
-    }
-};
+}
 
 class SyncHook {
+    constructor(type) {
+        this.type = '';
+        this.listeners = new Set();
+        if (type) {
+            this.type = type;
+        }
+    }
     on(fn) {
         if (typeof fn === 'function') {
             this.listeners.add(fn);
@@ -1586,7 +1682,7 @@ class SyncHook {
         let result;
         if (this.listeners.size > 0) {
             // eslint-disable-next-line prefer-spread
-            this.listeners.forEach((fn)=>{
+            this.listeners.forEach((fn) => {
                 result = fn(...data);
             });
         }
@@ -1598,13 +1694,6 @@ class SyncHook {
     removeAll() {
         this.listeners.clear();
     }
-    constructor(type){
-        this.type = '';
-        this.listeners = new Set();
-        if (type) {
-            this.type = type;
-        }
-    }
 }
 
 class AsyncHook extends SyncHook {
@@ -1613,12 +1702,14 @@ class AsyncHook extends SyncHook {
         const ls = Array.from(this.listeners);
         if (ls.length > 0) {
             let i = 0;
-            const call = (prev)=>{
+            const call = (prev) => {
                 if (prev === false) {
                     return false; // Abort process
-                } else if (i < ls.length) {
+                }
+                else if (i < ls.length) {
                     return Promise.resolve(ls[i++].apply(null, data)).then(call);
-                } else {
+                }
+                else {
                     return prev;
                 }
             };
@@ -1635,7 +1726,7 @@ function checkReturnData(originalData, returnedData) {
     }
     if (originalData !== returnedData) {
         // eslint-disable-next-line no-restricted-syntax
-        for(const key in originalData){
+        for (const key in originalData) {
             if (!(key in returnedData)) {
                 return false;
             }
@@ -1644,34 +1735,41 @@ function checkReturnData(originalData, returnedData) {
     return true;
 }
 class SyncWaterfallHook extends SyncHook {
+    constructor(type) {
+        super();
+        this.onerror = error;
+        this.type = type;
+    }
     emit(data) {
         if (!isObject(data)) {
             error(`The data for the "${this.type}" hook should be an object.`);
         }
-        for (const fn of this.listeners){
+        for (const fn of this.listeners) {
             try {
                 const tempData = fn(data);
                 if (checkReturnData(data, tempData)) {
                     data = tempData;
-                } else {
+                }
+                else {
                     this.onerror(`A plugin returned an unacceptable value for the "${this.type}" type.`);
                     break;
                 }
-            } catch (e) {
+            }
+            catch (e) {
                 warn(e);
                 this.onerror(e);
             }
         }
         return data;
     }
-    constructor(type){
+}
+
+class AsyncWaterfallHook extends SyncHook {
+    constructor(type) {
         super();
         this.onerror = error;
         this.type = type;
     }
-}
-
-class AsyncWaterfallHook extends SyncHook {
     emit(data) {
         if (!isObject(data)) {
             error(`The response data for the "${this.type}" hook must be an object.`);
@@ -1679,22 +1777,24 @@ class AsyncWaterfallHook extends SyncHook {
         const ls = Array.from(this.listeners);
         if (ls.length > 0) {
             let i = 0;
-            const processError = (e)=>{
+            const processError = (e) => {
                 warn(e);
                 this.onerror(e);
                 return data;
             };
-            const call = (prevData)=>{
+            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) {
+                        }
+                        catch (e) {
                             return processError(e);
                         }
                     }
-                } else {
+                }
+                else {
                     this.onerror(`A plugin returned an incorrect value for the "${this.type}" type.`);
                 }
                 return data;
@@ -1703,14 +1803,14 @@ class AsyncWaterfallHook extends SyncHook {
         }
         return Promise.resolve(data);
     }
-    constructor(type){
-        super();
-        this.onerror = error;
-        this.type = type;
-    }
 }
 
 class PluginSystem {
+    constructor(lifecycle) {
+        this.registerPlugins = {};
+        this.lifecycle = lifecycle;
+        this.lifecycleKeys = Object.keys(lifecycle);
+    }
     applyPlugin(plugin, instance) {
         assert(isPlainObject(plugin), 'Plugin configuration is invalid.');
         // The plugin's name is mandatory and must be unique
@@ -1718,8 +1818,8 @@ class PluginSystem {
         assert(pluginName, 'A name must be provided by the plugin.');
         if (!this.registerPlugins[pluginName]) {
             this.registerPlugins[pluginName] = plugin;
-            plugin.apply == null ? void 0 : plugin.apply.call(plugin, instance);
-            Object.keys(this.lifecycle).forEach((key)=>{
+            plugin.apply?.(instance);
+            Object.keys(this.lifecycle).forEach((key) => {
                 const pluginLife = plugin[key];
                 if (pluginLife) {
                     this.lifecycle[key].on(pluginLife);
@@ -1731,17 +1831,12 @@ class PluginSystem {
         assert(pluginName, 'A name is required.');
         const plugin = this.registerPlugins[pluginName];
         assert(plugin, `The plugin "${pluginName}" is not registered.`);
-        Object.keys(plugin).forEach((key)=>{
+        Object.keys(plugin).forEach((key) => {
             if (key !== 'name') {
                 this.lifecycle[key].remove(plugin[key]);
             }
         });
     }
-    constructor(lifecycle){
-        this.registerPlugins = {};
-        this.lifecycle = lifecycle;
-        this.lifecycleKeys = Object.keys(lifecycle);
-    }
 }
 
 function assignRemoteInfo(remoteInfo, remoteSnapshot) {
@@ -1762,12 +1857,12 @@ function assignRemoteInfo(remoteInfo, remoteSnapshot) {
 function snapshotPlugin() {
     return {
         name: 'snapshot-plugin',
-        async afterResolve (args) {
+        async afterResolve(args) {
             const { remote, pkgNameOrAlias, expose, origin, remoteInfo, id } = args;
             if (!isRemoteInfoWithEntry(remote) || !isPureRemoteEntry(remote)) {
                 const { remoteSnapshot, globalSnapshot } = await origin.snapshotHandler.loadRemoteSnapshotInfo({
                     moduleInfo: remote,
-                    id
+                    id,
                 });
                 assignRemoteInfo(remoteInfo, remoteSnapshot);
                 // preloading assets
@@ -1775,13 +1870,11 @@ function snapshotPlugin() {
                     remote,
                     preloadConfig: {
                         nameOrAlias: pkgNameOrAlias,
-                        exposes: [
-                            expose
-                        ],
+                        exposes: [expose],
                         resourceCategory: 'sync',
                         share: false,
-                        depsRemote: false
-                    }
+                        depsRemote: false,
+                    },
                 };
                 const assets = await origin.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
                     origin,
@@ -1789,17 +1882,18 @@ function snapshotPlugin() {
                     remoteInfo,
                     remote,
                     remoteSnapshot,
-                    globalSnapshot
+                    globalSnapshot,
                 });
                 if (assets) {
                     preloadAssets(remoteInfo, origin, assets, false);
                 }
-                return _extends({}, args, {
-                    remoteSnapshot
-                });
+                return {
+                    ...args,
+                    remoteSnapshot,
+                };
             }
             return args;
-        }
+        },
     };
 }
 
@@ -1810,17 +1904,19 @@ function splitId(id) {
     if (splitInfo.length === 1) {
         return {
             name: splitInfo[0],
-            version: undefined
+            version: undefined,
         };
-    } else if (splitInfo.length === 2) {
+    }
+    else if (splitInfo.length === 2) {
         return {
             name: splitInfo[0],
-            version: splitInfo[1]
+            version: splitInfo[1],
         };
-    } else {
+    }
+    else {
         return {
             name: splitInfo[1],
-            version: splitInfo[2]
+            version: splitInfo[2],
         };
     }
 }
@@ -1833,7 +1929,7 @@ function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot, memo =
         traverse(effectiveRemoteSnapshot, remoteInfo, isRoot);
         if (effectiveRemoteSnapshot.remotesInfo) {
             const remoteKeys = Object.keys(effectiveRemoteSnapshot.remotesInfo);
-            for (const key of remoteKeys){
+            for (const key of remoteKeys) {
                 if (memo[key]) {
                     continue;
                 }
@@ -1842,13 +1938,13 @@ function traverseModuleInfo(globalSnapshot, remoteInfo, traverse, isRoot, memo =
                 const remoteValue = effectiveRemoteSnapshot.remotesInfo[key];
                 traverseModuleInfo(globalSnapshot, {
                     name: subRemoteInfo.name,
-                    version: remoteValue.matchedVersion
+                    version: remoteValue.matchedVersion,
                 }, traverse, false, memo, undefined);
             }
         }
     }
 }
-const isExisted = (type, url)=>{
+const isExisted = (type, url) => {
     return document.querySelector(`${type}[${type === 'link' ? 'href' : 'src'}="${url}"]`);
 };
 // eslint-disable-next-line max-lines-per-function
@@ -1862,15 +1958,17 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
     const { preloadConfig: rootPreloadConfig } = preloadOptions;
     const { depsRemote } = rootPreloadConfig;
     const memo = {};
-    traverseModuleInfo(globalSnapshot, remote, (moduleInfoSnapshot, remoteInfo, isRoot)=>{
+    traverseModuleInfo(globalSnapshot, remote, (moduleInfoSnapshot, remoteInfo, isRoot) => {
         let preloadConfig;
         if (isRoot) {
             preloadConfig = rootPreloadConfig;
-        } else {
+        }
+        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) {
+                const findPreloadConfig = depsRemote.find((remoteConfig) => {
+                    if (remoteConfig.nameOrAlias === remoteInfo.name ||
+                        remoteConfig.nameOrAlias === remoteInfo.alias) {
                         return true;
                     }
                     return false;
@@ -1879,9 +1977,11 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
                     return;
                 }
                 preloadConfig = defaultPreloadArgs(findPreloadConfig);
-            } else if (depsRemote === true) {
+            }
+            else if (depsRemote === true) {
                 preloadConfig = rootPreloadConfig;
-            } else {
+            }
+            else {
                 return;
             }
         }
@@ -1892,27 +1992,33 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
                 moduleInfo: {
                     name: remoteInfo.name,
                     entry: remoteEntryUrl,
-                    type: 'remoteEntryType' in moduleInfoSnapshot ? moduleInfoSnapshot.remoteEntryType : 'global',
-                    entryGlobalName: 'globalName' in moduleInfoSnapshot ? moduleInfoSnapshot.globalName : remoteInfo.name,
+                    type: 'remoteEntryType' in moduleInfoSnapshot
+                        ? moduleInfoSnapshot.remoteEntryType
+                        : 'global',
+                    entryGlobalName: 'globalName' in moduleInfoSnapshot
+                        ? moduleInfoSnapshot.globalName
+                        : remoteInfo.name,
                     shareScope: '',
-                    version: 'version' in moduleInfoSnapshot ? moduleInfoSnapshot.version : undefined
+                    version: 'version' in moduleInfoSnapshot
+                        ? moduleInfoSnapshot.version
+                        : undefined,
                 },
-                url: remoteEntryUrl
+                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) {
+            moduleAssetsInfo = moduleInfoSnapshot?.modules?.reduce((assets, moduleAssetInfo) => {
+                if (normalizedPreloadExposes?.indexOf(moduleAssetInfo.moduleName) !==
+                    -1) {
                     assets.push(moduleAssetInfo);
                 }
                 return assets;
             }, []);
         }
         function handleAssets(assets) {
-            const assetsRes = assets.map((asset)=>getResourceUrl(moduleInfoSnapshot, asset));
+            const assetsRes = assets.map((asset) => getResourceUrl(moduleInfoSnapshot, asset));
             if (preloadConfig.filter) {
                 return assetsRes.filter(preloadConfig.filter);
             }
@@ -1920,7 +2026,7 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
         }
         if (moduleAssetsInfo) {
             const assetsLength = moduleAssetsInfo.length;
-            for(let index = 0; index < assetsLength; index++){
+            for (let index = 0; index < assetsLength; index++) {
                 const assetsInfo = moduleAssetsInfo[index];
                 const exposeFullPath = `${remoteInfo.name}/${assetsInfo.moduleName}`;
                 origin.remoteHandler.hooks.lifecycle.handlePreloadModule.emit({
@@ -1929,7 +2035,7 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
                     remoteSnapshot: moduleInfoSnapshot,
                     preloadConfig,
                     remote: remoteInfo,
-                    origin
+                    origin,
                 });
                 const preloaded = getPreloaded(exposeFullPath);
                 if (preloaded) {
@@ -1940,8 +2046,9 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
                     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') {
+                    // 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));
                 }
@@ -1950,53 +2057,54 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
         }
     }, true, memo, remoteSnapshot);
     if (remoteSnapshot.shared && remoteSnapshot.shared.length > 0) {
-        const collectSharedAssets = (shareInfo, snapshotShared)=>{
+        const collectSharedAssets = (shareInfo, snapshotShared) => {
             const registeredShared = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare);
             // 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 (registeredShared && typeof registeredShared.lib === 'function') {
-                snapshotShared.assets.js.sync.forEach((asset)=>{
+                snapshotShared.assets.js.sync.forEach((asset) => {
                     loadedSharedJsAssets.add(asset);
                 });
-                snapshotShared.assets.css.sync.forEach((asset)=>{
+                snapshotShared.assets.css.sync.forEach((asset) => {
                     loadedSharedCssAssets.add(asset);
                 });
             }
         };
-        remoteSnapshot.shared.forEach((shared)=>{
-            var _options_shared;
-            const shareInfos = (_options_shared = options.shared) == null ? void 0 : _options_shared[shared.sharedName];
+        remoteSnapshot.shared.forEach((shared) => {
+            const shareInfos = options.shared?.[shared.sharedName];
             if (!shareInfos) {
                 return;
             }
             // if no version, preload all shared
-            const sharedOptions = shared.version ? shareInfos.find((s)=>s.version === shared.version) : shareInfos;
+            const sharedOptions = shared.version
+                ? shareInfos.find((s) => s.version === shared.version)
+                : shareInfos;
             if (!sharedOptions) {
                 return;
             }
             const arrayShareInfo = arrayOptions(sharedOptions);
-            arrayShareInfo.forEach((s)=>{
+            arrayShareInfo.forEach((s) => {
                 collectSharedAssets(s, shared);
             });
         });
     }
-    const needPreloadJsAssets = jsAssets.filter((asset)=>!loadedSharedJsAssets.has(asset) && !isExisted('script', asset));
-    const needPreloadCssAssets = cssAssets.filter((asset)=>!loadedSharedCssAssets.has(asset) && !isExisted('link', asset));
+    const needPreloadJsAssets = jsAssets.filter((asset) => !loadedSharedJsAssets.has(asset) && !isExisted('script', asset));
+    const needPreloadCssAssets = cssAssets.filter((asset) => !loadedSharedCssAssets.has(asset) && !isExisted('link', asset));
     return {
         cssAssets: needPreloadCssAssets,
         jsAssetsWithoutEntry: needPreloadJsAssets,
-        entryAssets: entryAssets.filter((entry)=>!isExisted('script', entry.url))
+        entryAssets: entryAssets.filter((entry) => !isExisted('script', entry.url)),
     };
 }
-const generatePreloadAssetsPlugin = function() {
+const generatePreloadAssetsPlugin = function () {
     return {
         name: 'generate-preload-assets-plugin',
-        async generatePreloadAssets (args) {
-            const { origin, preloadOptions, remoteInfo, remote, globalSnapshot, remoteSnapshot } = args;
+        async generatePreloadAssets(args) {
+            const { origin, preloadOptions, remoteInfo, remote, globalSnapshot, remoteSnapshot, } = args;
             if (!isBrowserEnv()) {
                 return {
                     cssAssets: [],
                     jsAssetsWithoutEntry: [],
-                    entryAssets: []
+                    entryAssets: [],
                 };
             }
             if (isRemoteInfoWithEntry(remote) && isPureRemoteEntry(remote)) {
@@ -2012,34 +2120,37 @@ const generatePreloadAssetsPlugin = function() {
                                 entry: remote.entry,
                                 type: remoteInfo.type || 'global',
                                 entryGlobalName: '',
-                                shareScope: ''
-                            }
-                        }
-                    ]
+                                shareScope: '',
+                            },
+                        },
+                    ],
                 };
             }
             assignRemoteInfo(remoteInfo, remoteSnapshot);
             const assets = generatePreloadAssets(origin, preloadOptions, remoteInfo, globalSnapshot, remoteSnapshot);
             return assets;
-        }
+        },
     };
 };
 
 function getGlobalRemoteInfo(moduleInfo, origin) {
     const hostGlobalSnapshot = getGlobalSnapshotInfoByModuleInfo({
         name: origin.name,
-        version: origin.options.version
+        version: origin.options.version,
     });
     // get remote detail info from global
-    const globalRemoteInfo = hostGlobalSnapshot && 'remotesInfo' in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;
+    const globalRemoteInfo = hostGlobalSnapshot &&
+        'remotesInfo' in hostGlobalSnapshot &&
+        hostGlobalSnapshot.remotesInfo &&
+        getInfoWithoutType(hostGlobalSnapshot.remotesInfo, moduleInfo.name).value;
     if (globalRemoteInfo && globalRemoteInfo.matchedVersion) {
         return {
             hostGlobalSnapshot,
             globalSnapshot: getGlobalSnapshot(),
             remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
                 name: moduleInfo.name,
-                version: globalRemoteInfo.matchedVersion
-            })
+                version: globalRemoteInfo.matchedVersion,
+            }),
         };
     }
     return {
@@ -2047,77 +2158,100 @@ function getGlobalRemoteInfo(moduleInfo, origin) {
         globalSnapshot: getGlobalSnapshot(),
         remoteSnapshot: getGlobalSnapshotInfoByModuleInfo({
             name: moduleInfo.name,
-            version: 'version' in moduleInfo ? moduleInfo.version : undefined
-        })
+            version: 'version' in moduleInfo ? moduleInfo.version : undefined,
+        }),
     };
 }
 class SnapshotHandler {
+    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'),
+            afterLoadSnapshot: new AsyncWaterfallHook('afterLoadSnapshot'),
+        });
+        this.manifestLoading = Global.__FEDERATION__.__MANIFEST_LOADING__;
+        this.HostInstance = HostInstance;
+        this.loaderHook = HostInstance.loaderHook;
+    }
     // eslint-disable-next-line max-lines-per-function
-    async loadRemoteSnapshotInfo({ moduleInfo, id, expose }) {
+    async loadRemoteSnapshotInfo({ moduleInfo, id, expose, }) {
         const { options } = this.HostInstance;
         await this.hooks.lifecycle.beforeLoadRemoteSnapshot.emit({
             options,
-            moduleInfo
+            moduleInfo,
         });
         let hostSnapshot = getGlobalSnapshotInfoByModuleInfo({
             name: this.HostInstance.options.name,
-            version: this.HostInstance.options.version
+            version: this.HostInstance.options.version,
         });
         if (!hostSnapshot) {
             hostSnapshot = {
                 version: this.HostInstance.options.version || '',
                 remoteEntry: '',
-                remotesInfo: {}
+                remotesInfo: {},
             };
             addGlobalSnapshot({
-                [this.HostInstance.options.name]: hostSnapshot
+                [this.HostInstance.options.name]: hostSnapshot,
             });
         }
         // 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 && !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
+        if (hostSnapshot &&
+            'remotesInfo' in hostSnapshot &&
+            !getInfoWithoutType(hostSnapshot.remotesInfo, moduleInfo.name).value) {
             if ('version' in moduleInfo || 'entry' in moduleInfo) {
-                hostSnapshot.remotesInfo = _extends({}, hostSnapshot == null ? void 0 : hostSnapshot.remotesInfo, {
+                hostSnapshot.remotesInfo = {
+                    ...hostSnapshot?.remotesInfo,
                     [moduleInfo.name]: {
-                        matchedVersion: 'version' in moduleInfo ? moduleInfo.version : moduleInfo.entry
-                    }
-                });
+                        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({
+        const { remoteSnapshot: globalRemoteSnapshot, globalSnapshot: globalSnapshotRes, } = await this.hooks.lifecycle.loadSnapshot.emit({
             options,
             moduleInfo,
             hostGlobalSnapshot,
             remoteSnapshot,
-            globalSnapshot
+            globalSnapshot,
         });
         let mSnapshot;
         let gSnapshot;
         // global snapshot includes manifest or module info includes manifest
         if (globalRemoteSnapshot) {
             if (isManifestProvider(globalRemoteSnapshot)) {
-                const remoteEntry = isBrowserEnv() ? globalRemoteSnapshot.remoteEntry : globalRemoteSnapshot.ssrRemoteEntry || globalRemoteSnapshot.remoteEntry || '';
+                const remoteEntry = isBrowserEnv()
+                    ? globalRemoteSnapshot.remoteEntry
+                    : globalRemoteSnapshot.ssrRemoteEntry ||
+                        globalRemoteSnapshot.remoteEntry ||
+                        '';
                 const moduleSnapshot = await this.getManifestJson(remoteEntry, moduleInfo, {});
                 // eslint-disable-next-line @typescript-eslint/no-shadow
-                const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo(_extends({}, moduleInfo, {
+                const globalSnapshotRes = setGlobalSnapshotInfoByModuleInfo({
+                    ...moduleInfo,
                     // The global remote may be overridden
                     // Therefore, set the snapshot key to the global address of the actual request
-                    entry: remoteEntry
-                }), moduleSnapshot);
+                    entry: remoteEntry,
+                }, moduleSnapshot);
                 mSnapshot = moduleSnapshot;
                 gSnapshot = globalSnapshotRes;
-            } else {
+            }
+            else {
                 const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
                     options: this.HostInstance.options,
                     moduleInfo,
                     remoteSnapshot: globalRemoteSnapshot,
-                    from: 'global'
+                    from: 'global',
                 });
                 mSnapshot = remoteSnapshotRes;
                 gSnapshot = globalSnapshotRes;
             }
-        } else {
+        }
+        else {
             if (isRemoteInfoWithEntry(moduleInfo)) {
                 // get from manifest.json and merge remote info from remote server
                 const moduleSnapshot = await this.getManifestJson(moduleInfo.entry, moduleInfo, {});
@@ -2127,15 +2261,16 @@ class SnapshotHandler {
                     options: this.HostInstance.options,
                     moduleInfo,
                     remoteSnapshot: moduleSnapshot,
-                    from: 'global'
+                    from: 'global',
                 });
                 mSnapshot = remoteSnapshotRes;
                 gSnapshot = globalSnapshotRes;
-            } else {
+            }
+            else {
                 error(getShortErrorMsg(RUNTIME_007, runtimeDescMap, {
                     hostName: moduleInfo.name,
                     hostVersion: moduleInfo.version,
-                    globalSnapshot: JSON.stringify(globalSnapshotRes)
+                    globalSnapshot: JSON.stringify(globalSnapshotRes),
                 }));
             }
         }
@@ -2144,18 +2279,18 @@ class SnapshotHandler {
             host: this.HostInstance,
             options,
             moduleInfo,
-            remoteSnapshot: mSnapshot
+            remoteSnapshot: mSnapshot,
         });
         return {
             remoteSnapshot: mSnapshot,
-            globalSnapshot: gSnapshot
+            globalSnapshot: gSnapshot,
         };
     }
     getGlobalRemoteInfo(moduleInfo) {
         return getGlobalRemoteInfo(moduleInfo, this.HostInstance);
     }
     async getManifestJson(manifestUrl, moduleInfo, extraOptions) {
-        const getManifest = async ()=>{
+        const getManifest = async () => {
             let manifestJson = this.manifestCache.get(manifestUrl);
             if (manifestJson) {
                 return manifestJson;
@@ -2165,21 +2300,23 @@ class SnapshotHandler {
                 if (!res || !(res instanceof Response)) {
                     res = await fetch(manifestUrl, {});
                 }
-                manifestJson = await res.json();
-            } catch (err) {
-                manifestJson = await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
-                    id: manifestUrl,
-                    error: err,
-                    from: 'runtime',
-                    lifecycle: 'afterResolve',
-                    origin: this.HostInstance
-                });
+                manifestJson = (await res.json());
+            }
+            catch (err) {
+                manifestJson =
+                    (await this.HostInstance.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+                        id: manifestUrl,
+                        error: err,
+                        from: 'runtime',
+                        lifecycle: 'afterResolve',
+                        origin: this.HostInstance,
+                    }));
                 if (!manifestJson) {
                     delete this.manifestLoading[manifestUrl];
                     error(getShortErrorMsg(RUNTIME_003, runtimeDescMap, {
                         manifestUrl,
                         moduleName: moduleInfo.name,
-                        hostName: this.HostInstance.options.name
+                        hostName: this.HostInstance.options.name,
                     }, `${err}`));
                 }
             }
@@ -2187,10 +2324,10 @@ class SnapshotHandler {
             this.manifestCache.set(manifestUrl, manifestJson);
             return manifestJson;
         };
-        const asyncLoadProcess = async ()=>{
+        const asyncLoadProcess = async () => {
             const manifestJson = await getManifest();
             const remoteSnapshot = generateSnapshotFromManifest(manifestJson, {
-                version: manifestUrl
+                version: manifestUrl,
             });
             const { remoteSnapshot: remoteSnapshotRes } = await this.hooks.lifecycle.loadRemoteSnapshot.emit({
                 options: this.HostInstance.options,
@@ -2198,38 +2335,40 @@ class SnapshotHandler {
                 manifestJson,
                 remoteSnapshot,
                 manifestUrl,
-                from: 'manifest'
+                from: 'manifest',
             });
             return remoteSnapshotRes;
         };
         if (!this.manifestLoading[manifestUrl]) {
-            this.manifestLoading[manifestUrl] = asyncLoadProcess().then((res)=>res);
+            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'),
-            afterLoadSnapshot: new AsyncWaterfallHook('afterLoadSnapshot')
-        });
-        this.manifestLoading = Global.__FEDERATION__.__MANIFEST_LOADING__;
-        this.HostInstance = HostInstance;
-        this.loaderHook = HostInstance.loaderHook;
-    }
 }
 
 class SharedHandler {
+    constructor(host) {
+        this.hooks = new PluginSystem({
+            afterResolve: new AsyncWaterfallHook('afterResolve'),
+            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
+            // not used yet
+            loadShare: new AsyncHook(),
+            resolveShare: new SyncWaterfallHook('resolveShare'),
+            // maybe will change, temporarily for internal use only
+            initContainerShareScopeMap: new SyncWaterfallHook('initContainerShareScopeMap'),
+        });
+        this.host = host;
+        this.shareScopeMap = {};
+        this.initTokens = {};
+        this._setGlobalShareScopeMap(host.options);
+    }
     // register shared in shareScopeMap
     registerShared(globalOptions, userOptions) {
         const { shareInfos, shared } = formatShareConfigs(globalOptions, userOptions);
         const sharedKeys = Object.keys(shareInfos);
-        sharedKeys.forEach((sharedKey)=>{
+        sharedKeys.forEach((sharedKey) => {
             const sharedVals = shareInfos[sharedKey];
-            sharedVals.forEach((sharedVal)=>{
+            sharedVals.forEach((sharedVal) => {
                 const registeredShared = getRegisteredShare(this.shareScopeMap, sharedKey, sharedVal, this.hooks.lifecycle.resolveShare);
                 if (!registeredShared && sharedVal && sharedVal.lib) {
                     this.setShared({
@@ -2238,14 +2377,14 @@ class SharedHandler {
                         get: sharedVal.get,
                         loaded: true,
                         shared: sharedVal,
-                        from: userOptions.name
+                        from: userOptions.name,
                     });
                 }
             });
         });
         return {
             shareInfos,
-            shared
+            shared,
         };
     }
     async loadShare(pkgName, extraOptions) {
@@ -2257,12 +2396,12 @@ class SharedHandler {
         const shareOptions = getTargetSharedOptions({
             pkgName,
             extraOptions,
-            shareInfos: host.options.shared
+            shareInfos: host.options.shared,
         });
-        if (shareOptions == null ? void 0 : shareOptions.scope) {
-            await Promise.all(shareOptions.scope.map(async (shareScope)=>{
+        if (shareOptions?.scope) {
+            await Promise.all(shareOptions.scope.map(async (shareScope) => {
                 await Promise.all(this.initializeSharing(shareScope, {
-                    strategy: shareOptions.strategy
+                    strategy: shareOptions.strategy,
                 }));
                 return;
             }));
@@ -2271,14 +2410,14 @@ class SharedHandler {
             pkgName,
             shareInfo: shareOptions,
             shared: host.options.shared,
-            origin: host
+            origin: host,
         });
         const { shareInfo: shareOptionsRes } = loadShareRes;
         // Assert that shareInfoRes exists, if not, throw an error
         assert(shareOptionsRes, `Cannot find ${pkgName} Share in the ${host.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
         // Retrieve from cache
         const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare);
-        const addUseIn = (shared)=>{
+        const addUseIn = (shared) => {
             if (!shared.useIn) {
                 shared.useIn = [];
             }
@@ -2287,7 +2426,10 @@ class SharedHandler {
         if (registeredShared && registeredShared.lib) {
             addUseIn(registeredShared);
             return registeredShared.lib;
-        } else if (registeredShared && registeredShared.loading && !registeredShared.loaded) {
+        }
+        else if (registeredShared &&
+            registeredShared.loading &&
+            !registeredShared.loaded) {
             const factory = await registeredShared.loading;
             registeredShared.loaded = true;
             if (!registeredShared.lib) {
@@ -2295,8 +2437,9 @@ class SharedHandler {
             }
             addUseIn(registeredShared);
             return factory;
-        } else if (registeredShared) {
-            const asyncLoadProcess = async ()=>{
+        }
+        else if (registeredShared) {
+            const asyncLoadProcess = async () => {
                 const factory = await registeredShared.get();
                 addUseIn(registeredShared);
                 registeredShared.loaded = true;
@@ -2310,14 +2453,15 @@ class SharedHandler {
                 shared: registeredShared,
                 from: host.options.name,
                 lib: null,
-                loading
+                loading,
             });
             return loading;
-        } else {
-            if (extraOptions == null ? void 0 : extraOptions.customShareInfo) {
+        }
+        else {
+            if (extraOptions?.customShareInfo) {
                 return false;
             }
-            const asyncLoadProcess = async ()=>{
+            const asyncLoadProcess = async () => {
                 const factory = await shareOptionsRes.get();
                 shareOptionsRes.lib = factory;
                 shareOptionsRes.loaded = true;
@@ -2337,7 +2481,7 @@ class SharedHandler {
                 shared: shareOptionsRes,
                 from: host.options.name,
                 lib: null,
-                loading
+                loading,
             });
             return loading;
         }
@@ -2346,21 +2490,23 @@ class SharedHandler {
      * 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
+     */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
     initializeSharing(shareScopeName = DEFAULT_SCOPE, extraOptions) {
         const { host } = this;
-        const from = extraOptions == null ? void 0 : extraOptions.from;
-        const strategy = extraOptions == null ? void 0 : extraOptions.strategy;
-        let initScope = extraOptions == null ? void 0 : extraOptions.initScope;
+        const from = extraOptions?.from;
+        const strategy = extraOptions?.strategy;
+        let initScope = extraOptions?.initScope;
         const promises = [];
         if (from !== 'build') {
             const { initTokens } = this;
-            if (!initScope) initScope = [];
+            if (!initScope)
+                initScope = [];
             let initToken = initTokens[shareScopeName];
-            if (!initToken) initToken = initTokens[shareScopeName] = {
-                from: this.host.name
-            };
-            if (initScope.indexOf(initToken) >= 0) return promises;
+            if (!initToken)
+                initToken = initTokens[shareScopeName] = { from: this.host.name };
+            if (initScope.indexOf(initToken) >= 0)
+                return promises;
             initScope.push(initToken);
         }
         const shareScope = this.shareScopeMap;
@@ -2371,34 +2517,41 @@ class SharedHandler {
         }
         // Executes all initialization snippets from all accessible modules
         const scope = shareScope[shareScopeName];
-        const register = (name, shared)=>{
-            var _activeVersion_shareConfig;
+        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 = activeVersion.shareConfig) == null ? void 0 : _activeVersion_shareConfig.eager)));
-            if (!activeVersion || activeVersion.strategy !== 'loaded-first' && !activeVersion.loaded && (Boolean(!eager) !== !activeVersionEager ? eager : hostName > activeVersion.from)) {
+            const activeVersionEager = Boolean(activeVersion &&
+                (activeVersion.eager || activeVersion.shareConfig?.eager));
+            if (!activeVersion ||
+                (activeVersion.strategy !== 'loaded-first' &&
+                    !activeVersion.loaded &&
+                    (Boolean(!eager) !== !activeVersionEager
+                        ? eager
+                        : hostName > activeVersion.from))) {
                 versions[version] = shared;
             }
         };
-        const initFn = (mod)=>mod && mod.init && mod.init(shareScope[shareScopeName], initScope);
-        const initRemoteModule = async (key)=>{
+        const initFn = (mod) => mod && mod.init && mod.init(shareScope[shareScopeName], initScope);
+        const initRemoteModule = async (key) => {
             const { module } = await host.remoteHandler.getRemoteModuleAndOptions({
-                id: key
+                id: key,
             });
             if (module.getEntry) {
                 let remoteEntryExports;
                 try {
                     remoteEntryExports = await module.getEntry();
-                } catch (error) {
-                    remoteEntryExports = await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
-                        id: key,
-                        error,
-                        from: 'runtime',
-                        lifecycle: 'beforeLoadShare',
-                        origin: host
-                    });
+                }
+                catch (error) {
+                    remoteEntryExports =
+                        (await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+                            id: key,
+                            error,
+                            from: 'runtime',
+                            lifecycle: 'beforeLoadShare',
+                            origin: host,
+                        }));
                 }
                 if (!module.inited) {
                     await initFn(remoteEntryExports);
@@ -2406,17 +2559,18 @@ class SharedHandler {
                 }
             }
         };
-        Object.keys(host.options.shared).forEach((shareName)=>{
+        Object.keys(host.options.shared).forEach((shareName) => {
             const sharedArr = host.options.shared[shareName];
-            sharedArr.forEach((shared)=>{
+            sharedArr.forEach((shared) => {
                 if (shared.scope.includes(shareScopeName)) {
                     register(shareName, shared);
                 }
             });
         });
         // TODO: strategy==='version-first' need to be removed in the future
-        if (host.options.shareStrategy === 'version-first' || strategy === 'version-first') {
-            host.options.remotes.forEach((remote)=>{
+        if (host.options.shareStrategy === 'version-first' ||
+            strategy === 'version-first') {
+            host.options.remotes.forEach((remote) => {
                 if (remote.shareScope === shareScopeName) {
                     promises.push(initRemoteModule(remote.name));
                 }
@@ -2433,17 +2587,15 @@ class SharedHandler {
         const shareOptions = getTargetSharedOptions({
             pkgName,
             extraOptions,
-            shareInfos: host.options.shared
+            shareInfos: host.options.shared,
         });
-        if (shareOptions == null ? void 0 : shareOptions.scope) {
-            shareOptions.scope.forEach((shareScope)=>{
-                this.initializeSharing(shareScope, {
-                    strategy: shareOptions.strategy
-                });
+        if (shareOptions?.scope) {
+            shareOptions.scope.forEach((shareScope) => {
+                this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
             });
         }
         const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare);
-        const addUseIn = (shared)=>{
+        const addUseIn = (shared) => {
             if (!shared.useIn) {
                 shared.useIn = [];
             }
@@ -2469,7 +2621,7 @@ class SharedHandler {
                         loaded: true,
                         from: host.options.name,
                         lib: module,
-                        shared: registeredShared
+                        shared: registeredShared,
                     });
                     return module;
                 }
@@ -2484,10 +2636,10 @@ class SharedHandler {
         if (shareOptions.get) {
             const module = shareOptions.get();
             if (module instanceof Promise) {
-                const errorCode = (extraOptions == null ? void 0 : extraOptions.from) === 'build' ? RUNTIME_005 : RUNTIME_006;
+                const errorCode = extraOptions?.from === 'build' ? RUNTIME_005 : RUNTIME_006;
                 throw new Error(getShortErrorMsg(errorCode, runtimeDescMap, {
                     hostName: host.options.name,
-                    sharedPkgName: pkgName
+                    sharedPkgName: pkgName,
                 }));
             }
             shareOptions.lib = module;
@@ -2496,13 +2648,13 @@ class SharedHandler {
                 loaded: true,
                 from: host.options.name,
                 lib: shareOptions.lib,
-                shared: shareOptions
+                shared: shareOptions,
             });
             return shareOptions.lib;
         }
         throw new Error(getShortErrorMsg(RUNTIME_006, runtimeDescMap, {
             hostName: host.options.name,
-            sharedPkgName: pkgName
+            sharedPkgName: pkgName,
         }));
     }
     initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
@@ -2513,18 +2665,13 @@ class SharedHandler {
             options: host.options,
             origin: host,
             scopeName,
-            hostShareScopeMap: extraOptions.hostShareScopeMap
+            hostShareScopeMap: extraOptions.hostShareScopeMap,
         });
     }
-    setShared({ pkgName, shared, from, lib, loading, loaded, get }) {
-        const { version, scope = 'default' } = shared, shareInfo = _object_without_properties_loose(shared, [
-            "version",
-            "scope"
-        ]);
-        const scopes = Array.isArray(scope) ? scope : [
-            scope
-        ];
-        scopes.forEach((sc)=>{
+    setShared({ pkgName, shared, from, lib, loading, loaded, get, }) {
+        const { version, scope = 'default', ...shareInfo } = shared;
+        const scopes = Array.isArray(scope) ? scope : [scope];
+        scopes.forEach((sc) => {
             if (!this.shareScopeMap[sc]) {
                 this.shareScopeMap[sc] = {};
             }
@@ -2532,16 +2679,14 @@ class SharedHandler {
                 this.shareScopeMap[sc][pkgName] = {};
             }
             if (!this.shareScopeMap[sc][pkgName][version]) {
-                this.shareScopeMap[sc][pkgName][version] = _extends({
+                this.shareScopeMap[sc][pkgName][version] = {
                     version,
-                    scope: [
-                        'default'
-                    ]
-                }, shareInfo, {
+                    scope: ['default'],
+                    ...shareInfo,
                     lib,
                     loaded,
-                    loading
-                });
+                    loading,
+                };
                 if (get) {
                     this.shareScopeMap[sc][pkgName][version].get = get;
                 }
@@ -2566,54 +2711,45 @@ class SharedHandler {
             globalShareScopeMap[identifier] = this.shareScopeMap;
         }
     }
-    constructor(host){
+}
+
+class RemoteHandler {
+    constructor(host) {
         this.hooks = new PluginSystem({
-            afterResolve: new AsyncWaterfallHook('afterResolve'),
-            beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
+            beforeRegisterRemote: new SyncWaterfallHook('beforeRegisterRemote'),
+            registerRemote: new SyncWaterfallHook('registerRemote'),
+            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
+            onLoad: new AsyncHook('onLoad'),
+            handlePreloadModule: new SyncHook('handlePreloadModule'),
+            errorLoadRemote: new AsyncHook('errorLoadRemote'),
+            beforePreloadRemote: new AsyncHook('beforePreloadRemote'),
+            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
             // not used yet
-            loadShare: new AsyncHook(),
-            resolveShare: new SyncWaterfallHook('resolveShare'),
-            // maybe will change, temporarily for internal use only
-            initContainerShareScopeMap: new SyncWaterfallHook('initContainerShareScopeMap')
+            afterPreloadRemote: new AsyncHook(),
+            loadEntry: new AsyncHook(),
         });
         this.host = host;
-        this.shareScopeMap = {};
-        this.initTokens = {};
-        this._setGlobalShareScopeMap(host.options);
+        this.idToRemoteMap = {};
     }
-}
-
-class RemoteHandler {
     formatAndRegisterRemote(globalOptions, userOptions) {
         const userRemotes = userOptions.remotes || [];
-        return userRemotes.reduce((res, remote)=>{
-            this.registerRemote(remote, res, {
-                force: false
-            });
+        return userRemotes.reduce((res, remote) => {
+            this.registerRemote(remote, res, { force: false });
             return res;
         }, globalOptions.remotes);
     }
     setIdToRemoteMap(id, remoteMatchInfo) {
         const { remote, expose } = remoteMatchInfo;
         const { name, alias } = remote;
-        this.idToRemoteMap[id] = {
-            name: remote.name,
-            expose
-        };
+        this.idToRemoteMap[id] = { name: remote.name, expose };
         if (alias && id.startsWith(name)) {
             const idWithAlias = id.replace(name, alias);
-            this.idToRemoteMap[idWithAlias] = {
-                name: remote.name,
-                expose
-            };
+            this.idToRemoteMap[idWithAlias] = { name: remote.name, expose };
             return;
         }
         if (alias && id.startsWith(alias)) {
             const idWithName = id.replace(alias, name);
-            this.idToRemoteMap[idWithName] = {
-                name: remote.name,
-                expose
-            };
+            this.idToRemoteMap[idWithName] = { name: remote.name, expose };
         }
     }
     // eslint-disable-next-line max-lines-per-function
@@ -2622,7 +2758,7 @@ class RemoteHandler {
         const { host } = this;
         try {
             const { loadFactory = true } = options || {
-                loadFactory: true
+                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.
@@ -2632,10 +2768,10 @@ class RemoteHandler {
             // 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
+                id,
             });
-            const { pkgNameOrAlias, remote, expose, id: idRes, remoteSnapshot } = remoteMatchInfo;
-            const moduleOrFactory = await module.get(idRes, expose, options, remoteSnapshot);
+            const { pkgNameOrAlias, remote, expose, id: idRes, remoteSnapshot, } = remoteMatchInfo;
+            const moduleOrFactory = (await module.get(idRes, expose, options, remoteSnapshot));
             const moduleWrapper = await this.hooks.lifecycle.onLoad.emit({
                 id: idRes,
                 pkgNameOrAlias,
@@ -2645,23 +2781,22 @@ class RemoteHandler {
                 remote,
                 options: moduleOptions,
                 moduleInstance: module,
-                origin: host
+                origin: host,
             });
             this.setIdToRemoteMap(id, remoteMatchInfo);
             if (typeof moduleWrapper === 'function') {
                 return moduleWrapper;
             }
             return moduleOrFactory;
-        } catch (error) {
-            const { from = 'runtime' } = options || {
-                from: 'runtime'
-            };
+        }
+        catch (error) {
+            const { from = 'runtime' } = options || { from: 'runtime' };
             const failOver = await this.hooks.lifecycle.errorLoadRemote.emit({
                 id,
                 error,
                 from,
                 lifecycle: 'onLoad',
-                origin: host
+                origin: host,
             });
             if (!failOver) {
                 throw error;
@@ -2675,14 +2810,14 @@ class RemoteHandler {
         await this.hooks.lifecycle.beforePreloadRemote.emit({
             preloadOps: preloadOptions,
             options: host.options,
-            origin: host
+            origin: host,
         });
         const preloadOps = formatPreloadArgs(host.options.remotes, preloadOptions);
-        await Promise.all(preloadOps.map(async (ops)=>{
+        await Promise.all(preloadOps.map(async (ops) => {
             const { remote } = ops;
             const remoteInfo = getRemoteInfo(remote);
             const { globalSnapshot, remoteSnapshot } = await host.snapshotHandler.loadRemoteSnapshotInfo({
-                moduleInfo: remote
+                moduleInfo: remote,
             });
             const assets = await this.hooks.lifecycle.generatePreloadAssets.emit({
                 origin: host,
@@ -2690,7 +2825,7 @@ class RemoteHandler {
                 remote,
                 remoteInfo,
                 globalSnapshot,
-                remoteSnapshot
+                remoteSnapshot,
             });
             if (!assets) {
                 return;
@@ -2700,9 +2835,9 @@ class RemoteHandler {
     }
     registerRemotes(remotes, options) {
         const { host } = this;
-        remotes.forEach((remote)=>{
+        remotes.forEach((remote) => {
             this.registerRemote(remote, host.options.remotes, {
-                force: options == null ? void 0 : options.force
+                force: options?.force,
             });
         });
     }
@@ -2714,17 +2849,18 @@ class RemoteHandler {
             loadRemoteArgs = await this.hooks.lifecycle.beforeRequest.emit({
                 id,
                 options: host.options,
-                origin: host
+                origin: host,
             });
-        } catch (error) {
-            loadRemoteArgs = await this.hooks.lifecycle.errorLoadRemote.emit({
+        }
+        catch (error) {
+            loadRemoteArgs = (await this.hooks.lifecycle.errorLoadRemote.emit({
                 id,
                 options: host.options,
                 origin: host,
                 from: 'runtime',
                 error,
-                lifecycle: 'beforeRequest'
-            });
+                lifecycle: 'beforeRequest',
+            }));
             if (!loadRemoteArgs) {
                 throw error;
             }
@@ -2733,23 +2869,23 @@ class RemoteHandler {
         const remoteSplitInfo = matchRemoteWithNameAndExpose(host.options.remotes, idRes);
         assert(remoteSplitInfo, getShortErrorMsg(RUNTIME_004, runtimeDescMap, {
             hostName: host.options.name,
-            requestId: idRes
+            requestId: idRes,
         }));
         const { remote: rawRemote } = remoteSplitInfo;
         const remoteInfo = getRemoteInfo(rawRemote);
-        const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit(_extends({
-            id: idRes
-        }, remoteSplitInfo, {
+        const matchInfo = await host.sharedHandler.hooks.lifecycle.afterResolve.emit({
+            id: idRes,
+            ...remoteSplitInfo,
             options: host.options,
             origin: host,
-            remoteInfo
-        }));
+            remoteInfo,
+        });
         const { remote, expose } = matchInfo;
         assert(remote && expose, `The 'beforeRequest' hook was executed, but it failed to return the correct 'remote' and 'expose' values while loading ${idRes}.`);
         let module = host.moduleCache.get(remote.name);
         const moduleOptions = {
             host: host,
-            remoteInfo
+            remoteInfo,
         };
         if (!module) {
             module = new Module(moduleOptions);
@@ -2758,19 +2894,18 @@ class RemoteHandler {
         return {
             module,
             moduleOptions,
-            remoteMatchInfo: matchInfo
+            remoteMatchInfo: matchInfo,
         };
     }
     registerRemote(remote, targetRemotes, options) {
         const { host } = this;
-        const normalizeRemote = ()=>{
+        const normalizeRemote = () => {
             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 = targetRemotes.find((item)=>{
-                    var _item_alias;
-                    return remote.alias && (item.name.startsWith(remote.alias) || ((_item_alias = item.alias) == null ? void 0 : _item_alias.startsWith(remote.alias)));
-                });
+                const findEqual = targetRemotes.find((item) => remote.alias &&
+                    (item.name.startsWith(remote.alias) ||
+                        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
@@ -2786,32 +2921,24 @@ class RemoteHandler {
                 remote.type = DEFAULT_REMOTE_TYPE;
             }
         };
-        this.hooks.lifecycle.beforeRegisterRemote.emit({
-            remote,
-            origin: host
-        });
-        const registeredRemote = targetRemotes.find((item)=>item.name === remote.name);
+        this.hooks.lifecycle.beforeRegisterRemote.emit({ remote, origin: host });
+        const registeredRemote = targetRemotes.find((item) => item.name === remote.name);
         if (!registeredRemote) {
             normalizeRemote();
             targetRemotes.push(remote);
-            this.hooks.lifecycle.registerRemote.emit({
-                remote,
-                origin: host
-            });
-        } else {
+            this.hooks.lifecycle.registerRemote.emit({ remote, origin: host });
+        }
+        else {
             const messages = [
                 `The remote "${remote.name}" is already registered.`,
-                'Please note that overriding it may cause unexpected errors.'
+                'Please note that overriding it may cause unexpected errors.',
             ];
-            if (options == null ? void 0 : options.force) {
+            if (options?.force) {
                 // remove registered remote
                 this.removeRemote(registeredRemote);
                 normalizeRemote();
                 targetRemotes.push(remote);
-                this.hooks.lifecycle.registerRemote.emit({
-                    remote,
-                    origin: host
-                });
+                this.hooks.lifecycle.registerRemote.emit({ remote, origin: host });
                 warn$1(messages.join(' '));
             }
         }
@@ -2820,7 +2947,7 @@ class RemoteHandler {
         try {
             const { host } = this;
             const { name } = remote;
-            const remoteIndex = host.options.remotes.findIndex((item)=>item.name === name);
+            const remoteIndex = host.options.remotes.findIndex((item) => item.name === name);
             if (remoteIndex !== -1) {
                 host.options.remotes.splice(remoteIndex, 1);
             }
@@ -2829,10 +2956,10 @@ class RemoteHandler {
                 const remoteInfo = loadedModule.remoteInfo;
                 const key = remoteInfo.entryGlobalName;
                 if (CurrentGlobal[key]) {
-                    var _Object_getOwnPropertyDescriptor;
-                    if ((_Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(CurrentGlobal, key)) == null ? void 0 : _Object_getOwnPropertyDescriptor.configurable) {
+                    if (Object.getOwnPropertyDescriptor(CurrentGlobal, key)?.configurable) {
                         delete CurrentGlobal[key];
-                    } else {
+                    }
+                    else {
                         // @ts-ignore
                         CurrentGlobal[key] = undefined;
                     }
@@ -2843,11 +2970,14 @@ class RemoteHandler {
                 }
                 host.snapshotHandler.manifestCache.delete(remoteInfo.entry);
                 // delete unloaded shared and instance
-                let remoteInsId = remoteInfo.buildVersion ? composeKeyWithSeparator(remoteInfo.name, remoteInfo.buildVersion) : remoteInfo.name;
-                const remoteInsIndex = CurrentGlobal.__FEDERATION__.__INSTANCES__.findIndex((ins)=>{
+                let remoteInsId = remoteInfo.buildVersion
+                    ? composeKeyWithSeparator(remoteInfo.name, remoteInfo.buildVersion)
+                    : remoteInfo.name;
+                const remoteInsIndex = CurrentGlobal.__FEDERATION__.__INSTANCES__.findIndex((ins) => {
                     if (remoteInfo.buildVersion) {
                         return ins.options.id === remoteInsId;
-                    } else {
+                    }
+                    else {
                         return ins.name === remoteInsId;
                     }
                 });
@@ -2857,56 +2987,66 @@ class RemoteHandler {
                     const globalShareScopeMap = getGlobalShareScope();
                     let isAllSharedNotUsed = true;
                     const needDeleteKeys = [];
-                    Object.keys(globalShareScopeMap).forEach((instId)=>{
+                    Object.keys(globalShareScopeMap).forEach((instId) => {
                         const shareScopeMap = globalShareScopeMap[instId];
-                        shareScopeMap && Object.keys(shareScopeMap).forEach((shareScope)=>{
-                            const shareScopeVal = shareScopeMap[shareScope];
-                            shareScopeVal && Object.keys(shareScopeVal).forEach((shareName)=>{
-                                const sharedPkgs = shareScopeVal[shareName];
-                                sharedPkgs && Object.keys(sharedPkgs).forEach((shareVersion)=>{
-                                    const shared = sharedPkgs[shareVersion];
-                                    if (shared && typeof shared === 'object' && shared.from === remoteInfo.name) {
-                                        if (shared.loaded || shared.loading) {
-                                            shared.useIn = shared.useIn.filter((usedHostName)=>usedHostName !== remoteInfo.name);
-                                            if (shared.useIn.length) {
-                                                isAllSharedNotUsed = false;
-                                            } else {
-                                                needDeleteKeys.push([
-                                                    instId,
-                                                    shareScope,
-                                                    shareName,
-                                                    shareVersion
-                                                ]);
-                                            }
-                                        } else {
-                                            needDeleteKeys.push([
-                                                instId,
-                                                shareScope,
-                                                shareName,
-                                                shareVersion
-                                            ]);
-                                        }
-                                    }
-                                });
+                        shareScopeMap &&
+                            Object.keys(shareScopeMap).forEach((shareScope) => {
+                                const shareScopeVal = shareScopeMap[shareScope];
+                                shareScopeVal &&
+                                    Object.keys(shareScopeVal).forEach((shareName) => {
+                                        const sharedPkgs = shareScopeVal[shareName];
+                                        sharedPkgs &&
+                                            Object.keys(sharedPkgs).forEach((shareVersion) => {
+                                                const shared = sharedPkgs[shareVersion];
+                                                if (shared &&
+                                                    typeof shared === 'object' &&
+                                                    shared.from === remoteInfo.name) {
+                                                    if (shared.loaded || shared.loading) {
+                                                        shared.useIn = shared.useIn.filter((usedHostName) => usedHostName !== remoteInfo.name);
+                                                        if (shared.useIn.length) {
+                                                            isAllSharedNotUsed = false;
+                                                        }
+                                                        else {
+                                                            needDeleteKeys.push([
+                                                                instId,
+                                                                shareScope,
+                                                                shareName,
+                                                                shareVersion,
+                                                            ]);
+                                                        }
+                                                    }
+                                                    else {
+                                                        needDeleteKeys.push([
+                                                            instId,
+                                                            shareScope,
+                                                            shareName,
+                                                            shareVersion,
+                                                        ]);
+                                                    }
+                                                }
+                                            });
+                                    });
                             });
-                        });
                     });
                     if (isAllSharedNotUsed) {
                         remoteIns.shareScopeMap = {};
                         delete globalShareScopeMap[remoteInsId];
                     }
-                    needDeleteKeys.forEach(([insId, shareScope, shareName, shareVersion])=>{
-                        var _globalShareScopeMap_insId_shareScope_shareName, _globalShareScopeMap_insId_shareScope, _globalShareScopeMap_insId;
-                        (_globalShareScopeMap_insId = globalShareScopeMap[insId]) == null ? true : (_globalShareScopeMap_insId_shareScope = _globalShareScopeMap_insId[shareScope]) == null ? true : (_globalShareScopeMap_insId_shareScope_shareName = _globalShareScopeMap_insId_shareScope[shareName]) == null ? true : delete _globalShareScopeMap_insId_shareScope_shareName[shareVersion];
+                    needDeleteKeys.forEach(([insId, shareScope, shareName, shareVersion]) => {
+                        delete globalShareScopeMap[insId]?.[shareScope]?.[shareName]?.[shareVersion];
                     });
                     CurrentGlobal.__FEDERATION__.__INSTANCES__.splice(remoteInsIndex, 1);
                 }
                 const { hostGlobalSnapshot } = getGlobalRemoteInfo(remote, host);
                 if (hostGlobalSnapshot) {
-                    const remoteKey = hostGlobalSnapshot && 'remotesInfo' in hostGlobalSnapshot && hostGlobalSnapshot.remotesInfo && getInfoWithoutType(hostGlobalSnapshot.remotesInfo, remote.name).key;
+                    const remoteKey = hostGlobalSnapshot &&
+                        'remotesInfo' in hostGlobalSnapshot &&
+                        hostGlobalSnapshot.remotesInfo &&
+                        getInfoWithoutType(hostGlobalSnapshot.remotesInfo, remote.name).key;
                     if (remoteKey) {
                         delete hostGlobalSnapshot.remotesInfo[remoteKey];
-                        if (//eslint-disable-next-line no-extra-boolean-cast
+                        if (
+                        //eslint-disable-next-line no-extra-boolean-cast
                         Boolean(Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey])) {
                             delete Global.__FEDERATION__.__MANIFEST_LOADING__[remoteKey];
                         }
@@ -2914,31 +3054,68 @@ class RemoteHandler {
                 }
                 host.moduleCache.delete(remote.name);
             }
-        } catch (err) {
+        }
+        catch (err) {
             logger.log('removeRemote fail: ', err);
         }
     }
-    constructor(host){
-        this.hooks = new PluginSystem({
-            beforeRegisterRemote: new SyncWaterfallHook('beforeRegisterRemote'),
-            registerRemote: new SyncWaterfallHook('registerRemote'),
-            beforeRequest: new AsyncWaterfallHook('beforeRequest'),
-            onLoad: new AsyncHook('onLoad'),
-            handlePreloadModule: new SyncHook('handlePreloadModule'),
-            errorLoadRemote: new AsyncHook('errorLoadRemote'),
-            beforePreloadRemote: new AsyncHook('beforePreloadRemote'),
-            generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
-            // not used yet
-            afterPreloadRemote: new AsyncHook(),
-            loadEntry: new AsyncHook()
-        });
-        this.host = host;
-        this.idToRemoteMap = {};
-    }
 }
 
-const USE_SNAPSHOT = typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === 'boolean' ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true; // Default to true (use snapshot) when not explicitly defined
+const USE_SNAPSHOT = typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === 'boolean'
+    ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN
+    : true; // Default to true (use snapshot) when not explicitly defined
 class ModuleFederation {
+    constructor(userOptions) {
+        this.hooks = new PluginSystem({
+            beforeInit: new SyncWaterfallHook('beforeInit'),
+            init: new SyncHook(),
+            // maybe will change, temporarily for internal use only
+            beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
+            // maybe will change, temporarily for internal use only
+            initContainer: new AsyncWaterfallHook('initContainer'),
+        });
+        this.version = "0.20.0";
+        this.moduleCache = new Map();
+        this.loaderHook = new PluginSystem({
+            // FIXME: may not be suitable , not open to the public yet
+            getModuleInfo: new SyncHook(),
+            createScript: new SyncHook(),
+            createLink: new SyncHook(),
+            fetch: new AsyncHook(),
+            loadEntryError: new AsyncHook(),
+            getModuleFactory: new AsyncHook(),
+        });
+        this.bridgeHook = new PluginSystem({
+            beforeBridgeRender: new SyncHook(),
+            afterBridgeRender: new SyncHook(),
+            beforeBridgeDestroy: new SyncHook(),
+            afterBridgeDestroy: new SyncHook(),
+        });
+        const plugins = USE_SNAPSHOT
+            ? [snapshotPlugin(), generatePreloadAssetsPlugin()]
+            : [];
+        // TODO: Validate the details of the options
+        // Initialize options with default values
+        const defaultOptions = {
+            id: getBuilderId(),
+            name: userOptions.name,
+            plugins,
+            remotes: [],
+            shared: {},
+            inBrowser: isBrowserEnv(),
+        };
+        this.name = userOptions.name;
+        this.options = defaultOptions;
+        this.snapshotHandler = new SnapshotHandler(this);
+        this.sharedHandler = new SharedHandler(this);
+        this.remoteHandler = new RemoteHandler(this);
+        this.shareScopeMap = this.sharedHandler.shareScopeMap;
+        this.registerPlugins([
+            ...defaultOptions.plugins,
+            ...(userOptions.plugins || []),
+        ]);
+        this.options = this.formatOptions(defaultOptions, userOptions);
+    }
     initOptions(userOptions) {
         this.registerPlugins(userOptions.plugins);
         const options = this.formatOptions(this.options, userOptions);
@@ -2959,14 +3136,8 @@ class ModuleFederation {
         return this.sharedHandler.initializeSharing(shareScopeName, extraOptions);
     }
     initRawContainer(name, url, container) {
-        const remoteInfo = getRemoteInfo({
-            name,
-            entry: url
-        });
-        const module = new Module({
-            host: this,
-            remoteInfo
-        });
+        const remoteInfo = getRemoteInfo({ name, entry: url });
+        const module = new Module({ host: this, remoteInfo });
         module.remoteEntryExports = container;
         this.moduleCache.set(name, module);
         return module;
@@ -2989,37 +3160,38 @@ class ModuleFederation {
             origin: this,
             userOptions,
             options: globalOptions,
-            shareInfo: shared
+            shareInfo: shared,
         });
         const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
         const { shared: handledShared } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
-        const plugins = [
-            ...globalOptionsRes.plugins
-        ];
+        const plugins = [...globalOptionsRes.plugins];
         if (userOptionsRes.plugins) {
-            userOptionsRes.plugins.forEach((plugin)=>{
+            userOptionsRes.plugins.forEach((plugin) => {
                 if (!plugins.includes(plugin)) {
                     plugins.push(plugin);
                 }
             });
         }
-        const optionsRes = _extends({}, globalOptions, userOptions, {
+        const optionsRes = {
+            ...globalOptions,
+            ...userOptions,
             plugins,
             remotes,
-            shared: handledShared
-        });
+            shared: handledShared,
+        };
         this.hooks.lifecycle.init.emit({
             origin: this,
-            options: optionsRes
+            options: optionsRes,
         });
         return optionsRes;
     }
     registerPlugins(plugins) {
         const pluginRes = registerPlugins(plugins, this);
         // Merge plugin
-        this.options.plugins = this.options.plugins.reduce((res, plugin)=>{
-            if (!plugin) return res;
-            if (res && !res.find((item)=>item.name === plugin.name)) {
+        this.options.plugins = this.options.plugins.reduce((res, plugin) => {
+            if (!plugin)
+                return res;
+            if (res && !res.find((item) => item.name === plugin.name)) {
                 res.push(plugin);
             }
             return res;
@@ -3029,61 +3201,10 @@ class ModuleFederation {
         return this.remoteHandler.registerRemotes(remotes, options);
     }
     registerShared(shared) {
-        this.sharedHandler.registerShared(this.options, _extends({}, this.options, {
-            shared
-        }));
-    }
-    constructor(userOptions){
-        this.hooks = new PluginSystem({
-            beforeInit: new SyncWaterfallHook('beforeInit'),
-            init: new SyncHook(),
-            // maybe will change, temporarily for internal use only
-            beforeInitContainer: new AsyncWaterfallHook('beforeInitContainer'),
-            // maybe will change, temporarily for internal use only
-            initContainer: new AsyncWaterfallHook('initContainer')
-        });
-        this.version = "0.19.0";
-        this.moduleCache = new Map();
-        this.loaderHook = new PluginSystem({
-            // FIXME: may not be suitable , not open to the public yet
-            getModuleInfo: new SyncHook(),
-            createScript: new SyncHook(),
-            createLink: new SyncHook(),
-            fetch: new AsyncHook(),
-            loadEntryError: new AsyncHook(),
-            getModuleFactory: new AsyncHook()
-        });
-        this.bridgeHook = new PluginSystem({
-            beforeBridgeRender: new SyncHook(),
-            afterBridgeRender: new SyncHook(),
-            beforeBridgeDestroy: new SyncHook(),
-            afterBridgeDestroy: new SyncHook()
+        this.sharedHandler.registerShared(this.options, {
+            ...this.options,
+            shared,
         });
-        const plugins = USE_SNAPSHOT ? [
-            snapshotPlugin(),
-            generatePreloadAssetsPlugin()
-        ] : [];
-        // TODO: Validate the details of the options
-        // Initialize options with default values
-        const defaultOptions = {
-            id: getBuilderId(),
-            name: userOptions.name,
-            plugins,
-            remotes: [],
-            shared: {},
-            inBrowser: isBrowserEnv()
-        };
-        this.name = userOptions.name;
-        this.options = defaultOptions;
-        this.snapshotHandler = new SnapshotHandler(this);
-        this.sharedHandler = new SharedHandler(this);
-        this.remoteHandler = new RemoteHandler(this);
-        this.shareScopeMap = this.sharedHandler.shareScopeMap;
-        this.registerPlugins([
-            ...defaultOptions.plugins,
-            ...userOptions.plugins || []
-        ]);
-        this.options = this.formatOptions(defaultOptions, userOptions);
     }
 }