@module-federation/sdk 0.0.0-next-20250709075526 → 0.0.0-next-20250709090625

package/dist/index.cjs

@@ -0,0 +1,812 @@
+"use strict";
+var __webpack_modules__ = {
+    "./src/node.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            C: ()=>createScriptNode,
+            q: ()=>loadScriptNode
+        });
+        function importNodeModule(name) {
+            if (!name) throw new Error('import specifier is required');
+            const importModule = new Function('name', "return import(name)");
+            return importModule(name).then((res)=>res).catch((error)=>{
+                console.error(`Error importing module ${name}:`, error);
+                throw error;
+            });
+        }
+        const loadNodeFetch = async ()=>{
+            const fetchModule = await importNodeModule('node-fetch');
+            return fetchModule.default || fetchModule;
+        };
+        const lazyLoaderHookFetch = async (input, init, loaderHook)=>{
+            const hook = (url, init)=>loaderHook.lifecycle.fetch.emit(url, init);
+            const res = await hook(input, init || {});
+            if (!res || !(res instanceof Response)) {
+                const fetchFunction = 'undefined' == typeof fetch ? await loadNodeFetch() : fetch;
+                return fetchFunction(input, init || {});
+            }
+            return res;
+        };
+        const createScriptNode = 'undefined' == typeof ENV_TARGET || 'web' !== ENV_TARGET ? (url, cb, attrs, loaderHook)=>{
+            if (null == loaderHook ? void 0 : loaderHook.createScriptHook) {
+                const hookResult = loaderHook.createScriptHook(url);
+                if (hookResult && 'object' == typeof hookResult && 'url' in hookResult) url = hookResult.url;
+            }
+            let urlObj;
+            try {
+                urlObj = new URL(url);
+            } catch (e) {
+                console.error('Error constructing URL:', e);
+                cb(new Error(`Invalid URL: ${e}`));
+                return;
+            }
+            const getFetch = async ()=>{
+                if (null == loaderHook ? void 0 : loaderHook.fetch) return (input, init)=>lazyLoaderHookFetch(input, init, loaderHook);
+                return 'undefined' == typeof fetch ? loadNodeFetch() : fetch;
+            };
+            const handleScriptFetch = async (f, urlObj)=>{
+                try {
+                    var _vm_constants;
+                    const res = await f(urlObj.href);
+                    const data = await res.text();
+                    const [path, vm] = await Promise.all([
+                        importNodeModule('path'),
+                        importNodeModule('vm')
+                    ]);
+                    const scriptContext = {
+                        exports: {},
+                        module: {
+                            exports: {}
+                        }
+                    };
+                    const urlDirname = urlObj.pathname.split('/').slice(0, -1).join('/');
+                    const filename = path.basename(urlObj.pathname);
+                    const script = new vm.Script(`(function(exports, module, require, __dirname, __filename) {${data}\n})`, {
+                        filename,
+                        importModuleDynamically: (null == (_vm_constants = vm.constants) ? void 0 : _vm_constants.USE_MAIN_CONTEXT_DEFAULT_LOADER) ?? importNodeModule
+                    });
+                    script.runInThisContext()(scriptContext.exports, scriptContext.module, eval('require'), urlDirname, filename);
+                    const exportedInterface = scriptContext.module.exports || scriptContext.exports;
+                    if (attrs && exportedInterface && attrs['globalName']) {
+                        const container = exportedInterface[attrs['globalName']] || exportedInterface;
+                        cb(void 0, container);
+                        return;
+                    }
+                    cb(void 0, exportedInterface);
+                } catch (e) {
+                    cb(e instanceof Error ? e : new Error(`Script execution error: ${e}`));
+                }
+            };
+            getFetch().then(async (f)=>{
+                if ((null == attrs ? void 0 : attrs['type']) === 'esm' || (null == attrs ? void 0 : attrs['type']) === 'module') return loadModule(urlObj.href, {
+                    fetch: f,
+                    vm: await importNodeModule('vm')
+                }).then(async (module)=>{
+                    await module.evaluate();
+                    cb(void 0, module.namespace);
+                }).catch((e)=>{
+                    cb(e instanceof Error ? e : new Error(`Script execution error: ${e}`));
+                });
+                handleScriptFetch(f, urlObj);
+            }).catch((err)=>{
+                cb(err);
+            });
+        } : (url, cb, attrs, loaderHook)=>{
+            cb(new Error('createScriptNode is disabled in non-Node.js environment'));
+        };
+        const loadScriptNode = 'undefined' == typeof ENV_TARGET || 'web' !== ENV_TARGET ? (url, info)=>new Promise((resolve, reject)=>{
+                createScriptNode(url, (error, scriptContext)=>{
+                    if (error) reject(error);
+                    else {
+                        var _info_attrs, _info_attrs1;
+                        const remoteEntryKey = (null == info ? void 0 : null == (_info_attrs = info.attrs) ? void 0 : _info_attrs['globalName']) || `__FEDERATION_${null == info ? void 0 : null == (_info_attrs1 = info.attrs) ? void 0 : _info_attrs1['name']}:custom__`;
+                        const entryExports = globalThis[remoteEntryKey] = scriptContext;
+                        resolve(entryExports);
+                    }
+                }, info.attrs, info.loaderHook);
+            }) : (url, info)=>{
+            throw new Error('loadScriptNode is disabled in non-Node.js environment');
+        };
+        async function loadModule(url, options) {
+            const { fetch: fetch1, vm } = options;
+            const response = await fetch1(url);
+            const code = await response.text();
+            const module = new vm.SourceTextModule(code, {
+                importModuleDynamically: async (specifier, script)=>{
+                    const resolvedUrl = new URL(specifier, url).href;
+                    return loadModule(resolvedUrl, options);
+                }
+            });
+            await module.link(async (specifier)=>{
+                const resolvedUrl = new URL(specifier, url).href;
+                const module = await loadModule(resolvedUrl, options);
+                return module;
+            });
+            return module;
+        }
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        safeWrapper: ()=>safeWrapper,
+        safeToString: ()=>safeToString,
+        composeKeyWithSeparator: ()=>composeKeyWithSeparator,
+        error: ()=>utils_error,
+        getProcessEnv: ()=>getProcessEnv,
+        moduleFederationPlugin: ()=>ModuleFederationPlugin_namespaceObject,
+        generateExposeFilename: ()=>generateExposeFilename,
+        isManifestProvider: ()=>isManifestProvider,
+        encodeName: ()=>encodeName,
+        BROWSER_LOG_KEY: ()=>BROWSER_LOG_KEY,
+        NameTransformSymbol: ()=>NameTransformSymbol,
+        logger: ()=>logger,
+        MFModuleType: ()=>MFModuleType,
+        MFPrefetchCommon: ()=>MFPrefetchCommon,
+        createLink: ()=>createLink,
+        createScript: ()=>createScript,
+        isDebugMode: ()=>isDebugMode,
+        generateSnapshotFromManifest: ()=>generateSnapshotFromManifest,
+        isRequiredVersion: ()=>isRequiredVersion,
+        getResourceUrl: ()=>getResourceUrl,
+        TEMP_DIR: ()=>TEMP_DIR,
+        normalizeOptions: ()=>normalizeOptions,
+        loadScriptNode: ()=>node.q,
+        StatsFileName: ()=>StatsFileName,
+        assert: ()=>assert,
+        MANIFEST_EXT: ()=>MANIFEST_EXT,
+        FederationModuleManifest: ()=>FederationModuleManifest,
+        MODULE_DEVTOOL_IDENTIFIER: ()=>MODULE_DEVTOOL_IDENTIFIER,
+        createLogger: ()=>createLogger,
+        loadScript: ()=>loadScript,
+        EncodedNameTransformMap: ()=>EncodedNameTransformMap,
+        inferAutoPublicPath: ()=>inferAutoPublicPath,
+        SEPARATOR: ()=>SEPARATOR,
+        sharePlugin: ()=>SharePlugin_namespaceObject,
+        ENCODE_NAME_PREFIX: ()=>ENCODE_NAME_PREFIX,
+        isBrowserEnv: ()=>isBrowserEnv,
+        isStaticResourcesEqual: ()=>isStaticResourcesEqual,
+        createScriptNode: ()=>node.C,
+        containerReferencePlugin: ()=>ContainerReferencePlugin_namespaceObject,
+        simpleJoinRemoteEntry: ()=>simpleJoinRemoteEntry,
+        NameTransformMap: ()=>NameTransformMap,
+        containerPlugin: ()=>ContainerPlugin_namespaceObject,
+        decodeName: ()=>decodeName,
+        warn: ()=>warn,
+        createModuleFederationConfig: ()=>createModuleFederationConfig,
+        generateShareFilename: ()=>generateShareFilename,
+        ManifestFileName: ()=>ManifestFileName,
+        isReactNativeEnv: ()=>isReactNativeEnv,
+        parseEntry: ()=>parseEntry
+    });
+    var ContainerPlugin_namespaceObject = {};
+    __webpack_require__.r(ContainerPlugin_namespaceObject);
+    var ContainerReferencePlugin_namespaceObject = {};
+    __webpack_require__.r(ContainerReferencePlugin_namespaceObject);
+    var ModuleFederationPlugin_namespaceObject = {};
+    __webpack_require__.r(ModuleFederationPlugin_namespaceObject);
+    var SharePlugin_namespaceObject = {};
+    __webpack_require__.r(SharePlugin_namespaceObject);
+    const FederationModuleManifest = 'federation-manifest.json';
+    const MANIFEST_EXT = '.json';
+    const BROWSER_LOG_KEY = 'FEDERATION_DEBUG';
+    const NameTransformSymbol = {
+        AT: '@',
+        HYPHEN: '-',
+        SLASH: '/'
+    };
+    const NameTransformMap = {
+        [NameTransformSymbol.AT]: 'scope_',
+        [NameTransformSymbol.HYPHEN]: '_',
+        [NameTransformSymbol.SLASH]: '__'
+    };
+    const EncodedNameTransformMap = {
+        [NameTransformMap[NameTransformSymbol.AT]]: NameTransformSymbol.AT,
+        [NameTransformMap[NameTransformSymbol.HYPHEN]]: NameTransformSymbol.HYPHEN,
+        [NameTransformMap[NameTransformSymbol.SLASH]]: NameTransformSymbol.SLASH
+    };
+    const SEPARATOR = ':';
+    const ManifestFileName = 'mf-manifest.json';
+    const StatsFileName = 'mf-stats.json';
+    const MFModuleType = {
+        NPM: 'npm',
+        APP: 'app'
+    };
+    const MODULE_DEVTOOL_IDENTIFIER = '__MF_DEVTOOLS_MODULE_INFO__';
+    const ENCODE_NAME_PREFIX = 'ENCODE_NAME_PREFIX';
+    const TEMP_DIR = '.federation';
+    const MFPrefetchCommon = {
+        identifier: 'MFDataPrefetch',
+        globalKey: '__PREFETCH__',
+        library: 'mf-data-prefetch',
+        exportsKey: '__PREFETCH_EXPORTS__',
+        fileName: 'bootstrap.js'
+    };
+    function isBrowserEnv() {
+        return 'undefined' != typeof window && void 0 !== window.document;
+    }
+    function isReactNativeEnv() {
+        var _navigator;
+        return 'undefined' != typeof navigator && (null == (_navigator = navigator) ? void 0 : _navigator.product) === 'ReactNative';
+    }
+    function isBrowserDebug() {
+        try {
+            if (isBrowserEnv() && window.localStorage) return Boolean(localStorage.getItem(BROWSER_LOG_KEY));
+        } catch (error) {}
+        return false;
+    }
+    function isDebugMode() {
+        if ('undefined' != typeof process && process.env && process.env['FEDERATION_DEBUG']) return Boolean(process.env['FEDERATION_DEBUG']);
+        if ('undefined' != typeof FEDERATION_DEBUG && Boolean(FEDERATION_DEBUG)) return true;
+        return isBrowserDebug();
+    }
+    const getProcessEnv = function() {
+        return 'undefined' != typeof process && process.env ? process.env : {};
+    };
+    const LOG_CATEGORY = '[ Federation Runtime ]';
+    const parseEntry = (str, devVerOrUrl, separator = SEPARATOR)=>{
+        const strSplit = str.split(separator);
+        const devVersionOrUrl = 'development' === getProcessEnv()['NODE_ENV'] && devVerOrUrl;
+        const defaultVersion = '*';
+        const isEntry = (s)=>s.startsWith('http') || s.includes(MANIFEST_EXT);
+        if (strSplit.length >= 2) {
+            let [name, ...versionOrEntryArr] = strSplit;
+            if (str.startsWith(separator)) {
+                name = strSplit.slice(0, 2).join(separator);
+                versionOrEntryArr = [
+                    devVersionOrUrl || strSplit.slice(2).join(separator)
+                ];
+            }
+            let versionOrEntry = devVersionOrUrl || versionOrEntryArr.join(separator);
+            if (isEntry(versionOrEntry)) return {
+                name,
+                entry: versionOrEntry
+            };
+            return {
+                name,
+                version: versionOrEntry || defaultVersion
+            };
+        }
+        if (1 === strSplit.length) {
+            const [name] = strSplit;
+            if (devVersionOrUrl && isEntry(devVersionOrUrl)) return {
+                name,
+                entry: devVersionOrUrl
+            };
+            return {
+                name,
+                version: devVersionOrUrl || defaultVersion
+            };
+        }
+        throw `Invalid entry value: ${str}`;
+    };
+    const composeKeyWithSeparator = function(...args) {
+        if (!args.length) return '';
+        return args.reduce((sum, cur)=>{
+            if (!cur) return sum;
+            if (!sum) return cur;
+            return `${sum}${SEPARATOR}${cur}`;
+        }, '');
+    };
+    const encodeName = function(name, prefix = '', withExt = false) {
+        try {
+            const ext = withExt ? '.js' : '';
+            return `${prefix}${name.replace(new RegExp(`${NameTransformSymbol.AT}`, 'g'), NameTransformMap[NameTransformSymbol.AT]).replace(new RegExp(`${NameTransformSymbol.HYPHEN}`, 'g'), NameTransformMap[NameTransformSymbol.HYPHEN]).replace(new RegExp(`${NameTransformSymbol.SLASH}`, 'g'), NameTransformMap[NameTransformSymbol.SLASH])}${ext}`;
+        } catch (err) {
+            throw err;
+        }
+    };
+    const decodeName = function(name, prefix, withExt) {
+        try {
+            let decodedName = name;
+            if (prefix) {
+                if (!decodedName.startsWith(prefix)) return decodedName;
+                decodedName = decodedName.replace(new RegExp(prefix, 'g'), '');
+            }
+            decodedName = decodedName.replace(new RegExp(`${NameTransformMap[NameTransformSymbol.AT]}`, 'g'), EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.AT]]).replace(new RegExp(`${NameTransformMap[NameTransformSymbol.SLASH]}`, 'g'), EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.SLASH]]).replace(new RegExp(`${NameTransformMap[NameTransformSymbol.HYPHEN]}`, 'g'), EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.HYPHEN]]);
+            if (withExt) decodedName = decodedName.replace('.js', '');
+            return decodedName;
+        } catch (err) {
+            throw err;
+        }
+    };
+    const generateExposeFilename = (exposeName, withExt)=>{
+        if (!exposeName) return '';
+        let expose = exposeName;
+        if ('.' === expose) expose = 'default_export';
+        if (expose.startsWith('./')) expose = expose.replace('./', '');
+        return encodeName(expose, '__federation_expose_', withExt);
+    };
+    const generateShareFilename = (pkgName, withExt)=>{
+        if (!pkgName) return '';
+        return encodeName(pkgName, '__federation_shared_', withExt);
+    };
+    const getResourceUrl = (module, sourceUrl)=>{
+        if ('getPublicPath' in module) {
+            let publicPath;
+            publicPath = module.getPublicPath.startsWith('function') ? new Function('return ' + module.getPublicPath)()() : new Function(module.getPublicPath)();
+            return `${publicPath}${sourceUrl}`;
+        }
+        if ('publicPath' in module) {
+            if (!isBrowserEnv() && !isReactNativeEnv() && 'ssrPublicPath' in module) return `${module.ssrPublicPath}${sourceUrl}`;
+            return `${module.publicPath}${sourceUrl}`;
+        }
+        console.warn('Cannot get resource URL. If in debug mode, please ignore.', module, sourceUrl);
+        return '';
+    };
+    const assert = (condition, msg)=>{
+        if (!condition) utils_error(msg);
+    };
+    const utils_error = (msg)=>{
+        throw new Error(`${LOG_CATEGORY}: ${msg}`);
+    };
+    const warn = (msg)=>{
+        console.warn(`${LOG_CATEGORY}: ${msg}`);
+    };
+    function safeToString(info) {
+        try {
+            return JSON.stringify(info, null, 2);
+        } catch (e) {
+            return '';
+        }
+    }
+    const VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
+    function isRequiredVersion(str) {
+        return VERSION_PATTERN_REGEXP.test(str);
+    }
+    const simpleJoinRemoteEntry = (rPath, rName)=>{
+        if (!rPath) return rName;
+        const transformPath = (str)=>{
+            if ('.' === str) return '';
+            if (str.startsWith('./')) return str.replace('./', '');
+            if (str.startsWith('/')) {
+                const strWithoutSlash = str.slice(1);
+                if (strWithoutSlash.endsWith('/')) return strWithoutSlash.slice(0, -1);
+                return strWithoutSlash;
+            }
+            return str;
+        };
+        const transformedPath = transformPath(rPath);
+        if (!transformedPath) return rName;
+        if (transformedPath.endsWith('/')) return `${transformedPath}${rName}`;
+        return `${transformedPath}/${rName}`;
+    };
+    function inferAutoPublicPath(url) {
+        return url.replace(/#.*$/, '').replace(/\?.*$/, '').replace(/\/[^\/]+$/, '/');
+    }
+    function generateSnapshotFromManifest(manifest, options = {}) {
+        var _manifest_metaData, _manifest_metaData1;
+        const { remotes = {}, overrides = {}, version } = options;
+        let remoteSnapshot;
+        const getPublicPath = ()=>{
+            if (!('publicPath' in manifest.metaData)) return manifest.metaData.getPublicPath;
+            if ('auto' === manifest.metaData.publicPath && version) return inferAutoPublicPath(version);
+            return manifest.metaData.publicPath;
+        };
+        const overridesKeys = Object.keys(overrides);
+        let remotesInfo = {};
+        if (!Object.keys(remotes).length) {
+            var _manifest_remotes;
+            remotesInfo = (null == (_manifest_remotes = manifest.remotes) ? void 0 : _manifest_remotes.reduce((res, next)=>{
+                let matchedVersion;
+                const name = next.federationContainerName;
+                matchedVersion = overridesKeys.includes(name) ? overrides[name] : 'version' in next ? next.version : next.entry;
+                res[name] = {
+                    matchedVersion
+                };
+                return res;
+            }, {})) || {};
+        }
+        Object.keys(remotes).forEach((key)=>remotesInfo[key] = {
+                matchedVersion: overridesKeys.includes(key) ? overrides[key] : remotes[key]
+            });
+        const { remoteEntry: { path: remoteEntryPath, name: remoteEntryName, type: remoteEntryType }, types: remoteTypes, buildInfo: { buildVersion }, globalName, ssrRemoteEntry } = manifest.metaData;
+        const { exposes } = manifest;
+        let basicRemoteSnapshot = {
+            version: version ? version : '',
+            buildVersion,
+            globalName,
+            remoteEntry: simpleJoinRemoteEntry(remoteEntryPath, remoteEntryName),
+            remoteEntryType,
+            remoteTypes: simpleJoinRemoteEntry(remoteTypes.path, remoteTypes.name),
+            remoteTypesZip: remoteTypes.zip || '',
+            remoteTypesAPI: remoteTypes.api || '',
+            remotesInfo,
+            shared: null == manifest ? void 0 : manifest.shared.map((item)=>({
+                    assets: item.assets,
+                    sharedName: item.name,
+                    version: item.version
+                })),
+            modules: null == exposes ? void 0 : exposes.map((expose)=>({
+                    moduleName: expose.name,
+                    modulePath: expose.path,
+                    assets: expose.assets
+                }))
+        };
+        if (null == (_manifest_metaData = manifest.metaData) ? void 0 : _manifest_metaData.prefetchInterface) {
+            const prefetchInterface = manifest.metaData.prefetchInterface;
+            basicRemoteSnapshot = {
+                ...basicRemoteSnapshot,
+                prefetchInterface
+            };
+        }
+        if (null == (_manifest_metaData1 = manifest.metaData) ? void 0 : _manifest_metaData1.prefetchEntry) {
+            const { path, name, type } = manifest.metaData.prefetchEntry;
+            basicRemoteSnapshot = {
+                ...basicRemoteSnapshot,
+                prefetchEntry: simpleJoinRemoteEntry(path, name),
+                prefetchEntryType: type
+            };
+        }
+        remoteSnapshot = 'publicPath' in manifest.metaData ? {
+            ...basicRemoteSnapshot,
+            publicPath: getPublicPath(),
+            ssrPublicPath: manifest.metaData.ssrPublicPath
+        } : {
+            ...basicRemoteSnapshot,
+            getPublicPath: getPublicPath()
+        };
+        if (ssrRemoteEntry) {
+            const fullSSRRemoteEntry = simpleJoinRemoteEntry(ssrRemoteEntry.path, ssrRemoteEntry.name);
+            remoteSnapshot.ssrRemoteEntry = fullSSRRemoteEntry;
+            remoteSnapshot.ssrRemoteEntryType = ssrRemoteEntry.type || 'commonjs-module';
+        }
+        return remoteSnapshot;
+    }
+    function isManifestProvider(moduleInfo) {
+        if ('remoteEntry' in moduleInfo && moduleInfo.remoteEntry.includes(MANIFEST_EXT)) return true;
+        return false;
+    }
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    const PREFIX = '[ Module Federation ]';
+    class Logger {
+        setPrefix(prefix) {
+            this.prefix = prefix;
+        }
+        log(...args) {
+            console.log(this.prefix, ...args);
+        }
+        warn(...args) {
+            console.log(this.prefix, ...args);
+        }
+        error(...args) {
+            console.log(this.prefix, ...args);
+        }
+        success(...args) {
+            console.log(this.prefix, ...args);
+        }
+        info(...args) {
+            console.log(this.prefix, ...args);
+        }
+        ready(...args) {
+            console.log(this.prefix, ...args);
+        }
+        debug(...args) {
+            if (isDebugMode()) console.log(this.prefix, ...args);
+        }
+        constructor(prefix){
+            _define_property(this, "prefix", void 0);
+            this.prefix = prefix;
+        }
+    }
+    function createLogger(prefix) {
+        return new Logger(prefix);
+    }
+    const logger = createLogger(PREFIX);
+    async function safeWrapper(callback, disableWarn) {
+        try {
+            const res = await callback();
+            return res;
+        } catch (e) {
+            disableWarn || warn(e);
+            return;
+        }
+    }
+    function isStaticResourcesEqual(url1, url2) {
+        const REG_EXP = /^(https?:)?\/\//i;
+        const relativeUrl1 = url1.replace(REG_EXP, '').replace(/\/$/, '');
+        const relativeUrl2 = url2.replace(REG_EXP, '').replace(/\/$/, '');
+        return relativeUrl1 === relativeUrl2;
+    }
+    function createScript(info) {
+        let script = null;
+        let needAttach = true;
+        let timeout = 20000;
+        let timeoutId;
+        const scripts = document.getElementsByTagName("script");
+        for(let i = 0; i < scripts.length; i++){
+            const s = scripts[i];
+            const scriptSrc = s.getAttribute('src');
+            if (scriptSrc && isStaticResourcesEqual(scriptSrc, info.url)) {
+                script = s;
+                needAttach = false;
+                break;
+            }
+        }
+        if (!script) {
+            const attrs = info.attrs;
+            script = document.createElement("script");
+            script.type = (null == attrs ? void 0 : attrs['type']) === 'module' ? 'module' : "text/javascript";
+            let createScriptRes;
+            if (info.createScriptHook) {
+                createScriptRes = info.createScriptHook(info.url, info.attrs);
+                if (createScriptRes instanceof HTMLScriptElement) script = createScriptRes;
+                else if ('object' == typeof createScriptRes) {
+                    if ("script" in createScriptRes && createScriptRes.script) script = createScriptRes.script;
+                    if ('timeout' in createScriptRes && createScriptRes.timeout) timeout = createScriptRes.timeout;
+                }
+            }
+            if (!script.src) script.src = info.url;
+            if (attrs && !createScriptRes) Object.keys(attrs).forEach((name)=>{
+                if (script) {
+                    if ('async' === name || 'defer' === name) script[name] = attrs[name];
+                    else if (!script.getAttribute(name)) script.setAttribute(name, attrs[name]);
+                }
+            });
+        }
+        const onScriptComplete = async (prev, event)=>{
+            clearTimeout(timeoutId);
+            const onScriptCompleteCallback = ()=>{
+                if ((null == event ? void 0 : event.type) === 'error') (null == info ? void 0 : info.onErrorCallback) && (null == info || info.onErrorCallback(event));
+                else (null == info ? void 0 : info.cb) && (null == info || info.cb());
+            };
+            if (script) {
+                script.onerror = null;
+                script.onload = null;
+                safeWrapper(()=>{
+                    const { needDeleteScript = true } = info;
+                    if (needDeleteScript) (null == script ? void 0 : script.parentNode) && script.parentNode.removeChild(script);
+                });
+                if (prev && 'function' == typeof prev) {
+                    const result = prev(event);
+                    if (result instanceof Promise) {
+                        const res = await result;
+                        onScriptCompleteCallback();
+                        return res;
+                    }
+                    onScriptCompleteCallback();
+                    return result;
+                }
+            }
+            onScriptCompleteCallback();
+        };
+        script.onerror = onScriptComplete.bind(null, script.onerror);
+        script.onload = onScriptComplete.bind(null, script.onload);
+        timeoutId = setTimeout(()=>{
+            onScriptComplete(null, new Error(`Remote script "${info.url}" time-outed.`));
+        }, timeout);
+        return {
+            script,
+            needAttach
+        };
+    }
+    function createLink(info) {
+        let link = null;
+        let needAttach = true;
+        const links = document.getElementsByTagName('link');
+        for(let i = 0; i < links.length; i++){
+            const l = links[i];
+            const linkHref = l.getAttribute('href');
+            const linkRel = l.getAttribute('rel');
+            if (linkHref && isStaticResourcesEqual(linkHref, info.url) && linkRel === info.attrs['rel']) {
+                link = l;
+                needAttach = false;
+                break;
+            }
+        }
+        if (!link) {
+            link = document.createElement('link');
+            link.setAttribute('href', info.url);
+            let createLinkRes;
+            const attrs = info.attrs;
+            if (info.createLinkHook) {
+                createLinkRes = info.createLinkHook(info.url, attrs);
+                if (createLinkRes instanceof HTMLLinkElement) link = createLinkRes;
+            }
+            if (attrs && !createLinkRes) Object.keys(attrs).forEach((name)=>{
+                if (link && !link.getAttribute(name)) link.setAttribute(name, attrs[name]);
+            });
+        }
+        const onLinkComplete = (prev, event)=>{
+            const onLinkCompleteCallback = ()=>{
+                if ((null == event ? void 0 : event.type) === 'error') (null == info ? void 0 : info.onErrorCallback) && (null == info || info.onErrorCallback(event));
+                else (null == info ? void 0 : info.cb) && (null == info || info.cb());
+            };
+            if (link) {
+                link.onerror = null;
+                link.onload = null;
+                safeWrapper(()=>{
+                    const { needDeleteLink = true } = info;
+                    if (needDeleteLink) (null == link ? void 0 : link.parentNode) && link.parentNode.removeChild(link);
+                });
+                if (prev) {
+                    const res = prev(event);
+                    onLinkCompleteCallback();
+                    return res;
+                }
+            }
+            onLinkCompleteCallback();
+        };
+        link.onerror = onLinkComplete.bind(null, link.onerror);
+        link.onload = onLinkComplete.bind(null, link.onload);
+        return {
+            link,
+            needAttach
+        };
+    }
+    function loadScript(url, info) {
+        const { attrs = {}, createScriptHook } = info;
+        return new Promise((resolve, reject)=>{
+            const { script, needAttach } = createScript({
+                url,
+                cb: resolve,
+                onErrorCallback: reject,
+                attrs: {
+                    fetchpriority: 'high',
+                    ...attrs
+                },
+                createScriptHook,
+                needDeleteScript: true
+            });
+            needAttach && document.head.appendChild(script);
+        });
+    }
+    var node = __webpack_require__("./src/node.ts");
+    function normalizeOptions(enableDefault, defaultOptions, key) {
+        return function(options) {
+            if (false === options) return false;
+            if (void 0 === options) if (enableDefault) return defaultOptions;
+            else return false;
+            if (true === options) return defaultOptions;
+            if (options && 'object' == typeof options) return {
+                ...defaultOptions,
+                ...options
+            };
+            throw new Error(`Unexpected type for \`${key}\`, expect boolean/undefined/object, got: ${typeof options}`);
+        };
+    }
+    const createModuleFederationConfig = (options)=>options;
+})();
+exports.BROWSER_LOG_KEY = __webpack_exports__.BROWSER_LOG_KEY;
+exports.ENCODE_NAME_PREFIX = __webpack_exports__.ENCODE_NAME_PREFIX;
+exports.EncodedNameTransformMap = __webpack_exports__.EncodedNameTransformMap;
+exports.FederationModuleManifest = __webpack_exports__.FederationModuleManifest;
+exports.MANIFEST_EXT = __webpack_exports__.MANIFEST_EXT;
+exports.MFModuleType = __webpack_exports__.MFModuleType;
+exports.MFPrefetchCommon = __webpack_exports__.MFPrefetchCommon;
+exports.MODULE_DEVTOOL_IDENTIFIER = __webpack_exports__.MODULE_DEVTOOL_IDENTIFIER;
+exports.ManifestFileName = __webpack_exports__.ManifestFileName;
+exports.NameTransformMap = __webpack_exports__.NameTransformMap;
+exports.NameTransformSymbol = __webpack_exports__.NameTransformSymbol;
+exports.SEPARATOR = __webpack_exports__.SEPARATOR;
+exports.StatsFileName = __webpack_exports__.StatsFileName;
+exports.TEMP_DIR = __webpack_exports__.TEMP_DIR;
+exports.assert = __webpack_exports__.assert;
+exports.composeKeyWithSeparator = __webpack_exports__.composeKeyWithSeparator;
+exports.containerPlugin = __webpack_exports__.containerPlugin;
+exports.containerReferencePlugin = __webpack_exports__.containerReferencePlugin;
+exports.createLink = __webpack_exports__.createLink;
+exports.createLogger = __webpack_exports__.createLogger;
+exports.createModuleFederationConfig = __webpack_exports__.createModuleFederationConfig;
+exports.createScript = __webpack_exports__.createScript;
+exports.createScriptNode = __webpack_exports__.createScriptNode;
+exports.decodeName = __webpack_exports__.decodeName;
+exports.encodeName = __webpack_exports__.encodeName;
+exports.error = __webpack_exports__.error;
+exports.generateExposeFilename = __webpack_exports__.generateExposeFilename;
+exports.generateShareFilename = __webpack_exports__.generateShareFilename;
+exports.generateSnapshotFromManifest = __webpack_exports__.generateSnapshotFromManifest;
+exports.getProcessEnv = __webpack_exports__.getProcessEnv;
+exports.getResourceUrl = __webpack_exports__.getResourceUrl;
+exports.inferAutoPublicPath = __webpack_exports__.inferAutoPublicPath;
+exports.isBrowserEnv = __webpack_exports__.isBrowserEnv;
+exports.isDebugMode = __webpack_exports__.isDebugMode;
+exports.isManifestProvider = __webpack_exports__.isManifestProvider;
+exports.isReactNativeEnv = __webpack_exports__.isReactNativeEnv;
+exports.isRequiredVersion = __webpack_exports__.isRequiredVersion;
+exports.isStaticResourcesEqual = __webpack_exports__.isStaticResourcesEqual;
+exports.loadScript = __webpack_exports__.loadScript;
+exports.loadScriptNode = __webpack_exports__.loadScriptNode;
+exports.logger = __webpack_exports__.logger;
+exports.moduleFederationPlugin = __webpack_exports__.moduleFederationPlugin;
+exports.normalizeOptions = __webpack_exports__.normalizeOptions;
+exports.parseEntry = __webpack_exports__.parseEntry;
+exports.safeToString = __webpack_exports__.safeToString;
+exports.safeWrapper = __webpack_exports__.safeWrapper;
+exports.sharePlugin = __webpack_exports__.sharePlugin;
+exports.simpleJoinRemoteEntry = __webpack_exports__.simpleJoinRemoteEntry;
+exports.warn = __webpack_exports__.warn;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "BROWSER_LOG_KEY",
+    "ENCODE_NAME_PREFIX",
+    "EncodedNameTransformMap",
+    "FederationModuleManifest",
+    "MANIFEST_EXT",
+    "MFModuleType",
+    "MFPrefetchCommon",
+    "MODULE_DEVTOOL_IDENTIFIER",
+    "ManifestFileName",
+    "NameTransformMap",
+    "NameTransformSymbol",
+    "SEPARATOR",
+    "StatsFileName",
+    "TEMP_DIR",
+    "assert",
+    "composeKeyWithSeparator",
+    "containerPlugin",
+    "containerReferencePlugin",
+    "createLink",
+    "createLogger",
+    "createModuleFederationConfig",
+    "createScript",
+    "createScriptNode",
+    "decodeName",
+    "encodeName",
+    "error",
+    "generateExposeFilename",
+    "generateShareFilename",
+    "generateSnapshotFromManifest",
+    "getProcessEnv",
+    "getResourceUrl",
+    "inferAutoPublicPath",
+    "isBrowserEnv",
+    "isDebugMode",
+    "isManifestProvider",
+    "isReactNativeEnv",
+    "isRequiredVersion",
+    "isStaticResourcesEqual",
+    "loadScript",
+    "loadScriptNode",
+    "logger",
+    "moduleFederationPlugin",
+    "normalizeOptions",
+    "parseEntry",
+    "safeToString",
+    "safeWrapper",
+    "sharePlugin",
+    "simpleJoinRemoteEntry",
+    "warn"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});