@module-federation/sdk 0.3.0 → 0.3.2

package/dist/index.esm.js

@@ -0,0 +1,701 @@
+const FederationModuleManifest = 'federation-manifest.json';
+const MANIFEST_EXT = '.json';
+const BROWSER_LOG_KEY = 'FEDERATION_DEBUG';
+const BROWSER_LOG_VALUE = '1';
+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';
+
+var ContainerPlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var ContainerReferencePlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var ModuleFederationPlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var SharePlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+function isBrowserEnv() {
+    return typeof window !== 'undefined';
+}
+function isDebugMode() {
+    if (typeof process !== 'undefined' && process.env && process.env['FEDERATION_DEBUG']) {
+        return Boolean(process.env['FEDERATION_DEBUG']);
+    }
+    return typeof FEDERATION_DEBUG !== 'undefined' && Boolean(FEDERATION_DEBUG);
+}
+const getProcessEnv = function() {
+    return typeof process !== 'undefined' && process.env ? process.env : {};
+};
+
+function safeToString(info) {
+    try {
+        return JSON.stringify(info, null, 2);
+    } catch (e) {
+        return '';
+    }
+}
+const DEBUG_LOG = '[ FEDERATION DEBUG ]';
+function safeGetLocalStorageItem() {
+    try {
+        if (typeof window !== 'undefined' && window.localStorage) {
+            return localStorage.getItem(BROWSER_LOG_KEY) === BROWSER_LOG_VALUE;
+        }
+    } catch (error) {
+        return typeof document !== 'undefined';
+    }
+    return false;
+}
+let Logger = class Logger {
+    info(msg, info) {
+        if (this.enable) {
+            const argsToString = safeToString(info) || '';
+            if (isBrowserEnv()) {
+                console.info(`%c ${this.identifier}: ${msg} ${argsToString}`, 'color:#3300CC');
+            } else {
+                console.info('\x1b[34m%s', `${this.identifier}: ${msg} ${argsToString ? `\n${argsToString}` : ''}`);
+            }
+        }
+    }
+    logOriginalInfo(...args) {
+        if (this.enable) {
+            if (isBrowserEnv()) {
+                console.info(`%c ${this.identifier}: OriginalInfo`, 'color:#3300CC');
+                console.log(...args);
+            } else {
+                console.info(`%c ${this.identifier}: OriginalInfo`, 'color:#3300CC');
+                console.log(...args);
+            }
+        }
+    }
+    constructor(identifier){
+        this.enable = false;
+        this.identifier = identifier || DEBUG_LOG;
+        if (isBrowserEnv() && safeGetLocalStorageItem()) {
+            this.enable = true;
+        } else if (isDebugMode()) {
+            this.enable = true;
+        }
+    }
+};
+
+const LOG_CATEGORY = '[ Federation Runtime ]';
+// entry: name:version   version : 1.0.0 | ^1.2.3
+// entry: name:entry  entry:  https://localhost:9000/federation-manifest.json
+const parseEntry = (str, devVerOrUrl, separator = SEPARATOR)=>{
+    const strSplit = str.split(separator);
+    const devVersionOrUrl = getProcessEnv()['NODE_ENV'] === 'development' && devVerOrUrl;
+    const defaultVersion = '*';
+    const isEntry = (s)=>s.startsWith('http') || s.includes(MANIFEST_EXT);
+    // Check if the string starts with a type
+    if (strSplit.length >= 2) {
+        let [name, ...versionOrEntryArr] = strSplit;
+        if (str.startsWith(separator)) {
+            versionOrEntryArr = [
+                devVersionOrUrl || strSplit.slice(-1)[0]
+            ];
+            name = strSplit.slice(0, -1).join(separator);
+        }
+        let versionOrEntry = devVersionOrUrl || versionOrEntryArr.join(separator);
+        if (isEntry(versionOrEntry)) {
+            return {
+                name,
+                entry: versionOrEntry
+            };
+        } else {
+            // Apply version rule
+            // devVersionOrUrl => inputVersion => defaultVersion
+            return {
+                name,
+                version: versionOrEntry || defaultVersion
+            };
+        }
+    } else if (strSplit.length === 1) {
+        const [name] = strSplit;
+        if (devVersionOrUrl && isEntry(devVersionOrUrl)) {
+            return {
+                name,
+                entry: devVersionOrUrl
+            };
+        }
+        return {
+            name,
+            version: devVersionOrUrl || defaultVersion
+        };
+    } else {
+        throw `Invalid entry value: ${str}`;
+    }
+};
+const logger = new Logger();
+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;
+        if (!module.getPublicPath.startsWith('function')) {
+            publicPath = new Function(module.getPublicPath)();
+        } else {
+            publicPath = new Function('return ' + module.getPublicPath)()();
+        }
+        return `${publicPath}${sourceUrl}`;
+    } else if ('publicPath' in module) {
+        return `${module.publicPath}${sourceUrl}`;
+    } else {
+        console.warn('Cannot get resource URL. If in debug mode, please ignore.', module, sourceUrl);
+        return '';
+    }
+};
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+const assert = (condition, msg)=>{
+    if (!condition) {
+        error(msg);
+    }
+};
+const error = (msg)=>{
+    throw new Error(`${LOG_CATEGORY}: ${msg}`);
+};
+const warn = (msg)=>{
+    console.warn(`${LOG_CATEGORY}: ${msg}`);
+};
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+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(/\/[^\/]+$/, '/');
+}
+// Priority: overrides > remotes
+// eslint-disable-next-line max-lines-per-function
+function generateSnapshotFromManifest(manifest, options = {}) {
+    var _manifest_metaData, _manifest_metaData1;
+    const { remotes = {}, overrides = {}, version } = options;
+    let remoteSnapshot;
+    const getPublicPath = ()=>{
+        if ('publicPath' in manifest.metaData) {
+            if (manifest.metaData.publicPath === 'auto' && version) {
+                // use same implementation as publicPath auto runtime module implements
+                return inferAutoPublicPath(version);
+            }
+            return manifest.metaData.publicPath;
+        } else {
+            return manifest.metaData.getPublicPath;
+        }
+    };
+    const overridesKeys = Object.keys(overrides);
+    let remotesInfo = {};
+    // If remotes are not provided, only the remotes in the manifest will be read
+    if (!Object.keys(remotes).length) {
+        var _manifest_remotes;
+        remotesInfo = ((_manifest_remotes = manifest.remotes) == null ? void 0 : _manifest_remotes.reduce((res, next)=>{
+            let matchedVersion;
+            const name = next.federationContainerName;
+            // overrides have higher priority
+            if (overridesKeys.includes(name)) {
+                matchedVersion = overrides[name];
+            } else {
+                if ('version' in next) {
+                    matchedVersion = next.version;
+                } else {
+                    matchedVersion = next.entry;
+                }
+            }
+            res[name] = {
+                matchedVersion
+            };
+            return res;
+        }, {})) || {};
+    }
+    // If remotes (deploy scenario) are specified, they need to be traversed again
+    Object.keys(remotes).forEach((key)=>remotesInfo[key] = {
+            // overrides will override dependencies
+            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: manifest == null ? void 0 : manifest.shared.map((item)=>({
+                assets: item.assets,
+                sharedName: item.name,
+                version: item.version
+            })),
+        modules: exposes == null ? void 0 : exposes.map((expose)=>({
+                moduleName: expose.name,
+                modulePath: expose.path,
+                assets: expose.assets
+            }))
+    };
+    if ((_manifest_metaData = manifest.metaData) == null ? void 0 : _manifest_metaData.prefetchInterface) {
+        const prefetchInterface = manifest.metaData.prefetchInterface;
+        basicRemoteSnapshot = _extends({}, basicRemoteSnapshot, {
+            prefetchInterface
+        });
+    }
+    if ((_manifest_metaData1 = manifest.metaData) == null ? void 0 : _manifest_metaData1.prefetchEntry) {
+        const { path, name, type } = manifest.metaData.prefetchEntry;
+        basicRemoteSnapshot = _extends({}, basicRemoteSnapshot, {
+            prefetchEntry: simpleJoinRemoteEntry(path, name),
+            prefetchEntryType: type
+        });
+    }
+    if ('publicPath' in manifest.metaData) {
+        remoteSnapshot = _extends({}, basicRemoteSnapshot, {
+            publicPath: getPublicPath()
+        });
+    } else {
+        remoteSnapshot = _extends({}, basicRemoteSnapshot, {
+            getPublicPath: getPublicPath()
+        });
+    }
+    if (ssrRemoteEntry) {
+        const fullSSRRemoteEntry = simpleJoinRemoteEntry(ssrRemoteEntry.path, ssrRemoteEntry.name);
+        remoteSnapshot.ssrRemoteEntry = fullSSRRemoteEntry;
+        remoteSnapshot.ssrRemoteEntryType = 'commonjs-module';
+    }
+    return remoteSnapshot;
+}
+function isManifestProvider(moduleInfo) {
+    if ('remoteEntry' in moduleInfo && moduleInfo.remoteEntry.includes(MANIFEST_EXT)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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;
+    // Transform url1 and url2 into relative paths
+    const relativeUrl1 = url1.replace(REG_EXP, '').replace(/\/$/, '');
+    const relativeUrl2 = url2.replace(REG_EXP, '').replace(/\/$/, '');
+    // Check if the relative paths are identical
+    return relativeUrl1 === relativeUrl2;
+}
+function createScript(info) {
+    // Retrieve the existing script element by its src attribute
+    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) {
+        script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = info.url;
+        if (info.createScriptHook) {
+            const createScriptRes = info.createScriptHook(info.url, info.attrs);
+            if (createScriptRes instanceof HTMLScriptElement) {
+                script = createScriptRes;
+            } else if (typeof createScriptRes === 'object') {
+                if (createScriptRes.script) script = createScriptRes.script;
+                if (createScriptRes.timeout) timeout = createScriptRes.timeout;
+            }
+        }
+        const attrs = info.attrs;
+        if (attrs) {
+            Object.keys(attrs).forEach((name)=>{
+                if (script) {
+                    if (name === 'async' || name === 'defer') {
+                        script[name] = attrs[name];
+                    // Attributes that do not exist are considered overridden
+                    } else if (!script.getAttribute(name)) {
+                        script.setAttribute(name, attrs[name]);
+                    }
+                }
+            });
+        }
+    }
+    const onScriptComplete = (prev, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    event)=>{
+        var _info_cb;
+        clearTimeout(timeoutId);
+        // Prevent memory leaks in IE.
+        if (script) {
+            script.onerror = null;
+            script.onload = null;
+            safeWrapper(()=>{
+                const { needDeleteScript = true } = info;
+                if (needDeleteScript) {
+                    (script == null ? void 0 : script.parentNode) && script.parentNode.removeChild(script);
+                }
+            });
+            if (prev) {
+                var _info_cb1;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const res = prev(event);
+                info == null ? void 0 : (_info_cb1 = info.cb) == null ? void 0 : _info_cb1.call(info);
+                return res;
+            }
+        }
+        info == null ? void 0 : (_info_cb = info.cb) == null ? void 0 : _info_cb.call(info);
+    };
+    script.onerror = onScriptComplete.bind(null, script.onerror);
+    script.onload = onScriptComplete.bind(null, script.onload);
+    timeoutId = setTimeout(()=>{
+        onScriptComplete(null, new Error(`Remote script "${info.url}" time-outed.`));
+    }, timeout);
+    return {
+        script,
+        needAttach
+    };
+}
+function createLink(info) {
+    // <link rel="preload" href="script.js" as="script">
+    // Retrieve the existing script element by its src attribute
+    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 linkRef = l.getAttribute('ref');
+        if (linkHref && isStaticResourcesEqual(linkHref, info.url) && linkRef === info.attrs['ref']) {
+            link = l;
+            needAttach = false;
+            break;
+        }
+    }
+    if (!link) {
+        link = document.createElement('link');
+        link.setAttribute('href', info.url);
+        if (info.createLinkHook) {
+            const createLinkRes = info.createLinkHook(info.url);
+            if (createLinkRes instanceof HTMLLinkElement) {
+                link = createLinkRes;
+            }
+        }
+        const attrs = info.attrs;
+        if (attrs) {
+            Object.keys(attrs).forEach((name)=>{
+                if (link && !link.getAttribute(name)) {
+                    link.setAttribute(name, attrs[name]);
+                }
+            });
+        }
+    }
+    const onLinkComplete = (prev, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    event)=>{
+        // Prevent memory leaks in IE.
+        if (link) {
+            link.onerror = null;
+            link.onload = null;
+            safeWrapper(()=>{
+                const { needDeleteLink = true } = info;
+                if (needDeleteLink) {
+                    (link == null ? void 0 : link.parentNode) && link.parentNode.removeChild(link);
+                }
+            });
+            if (prev) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const res = prev(event);
+                info.cb();
+                return res;
+            }
+        }
+        info.cb();
+    };
+    link.onerror = onLinkComplete.bind(null, link.onerror);
+    link.onload = onLinkComplete.bind(null, link.onload);
+    return {
+        link,
+        needAttach
+    };
+}
+function loadScript(url, info) {
+    const { attrs = {}, createScriptHook } = info;
+    return new Promise((resolve, _reject)=>{
+        const { script, needAttach } = createScript({
+            url,
+            cb: resolve,
+            attrs: _extends({
+                fetchpriority: 'high'
+            }, attrs),
+            createScriptHook,
+            needDeleteScript: true
+        });
+        needAttach && document.head.appendChild(script);
+    });
+}
+
+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)=>{
+    // @ts-ignore
+    const loaderHooks = __webpack_require__.federation.instance.loaderHook;
+    const hook = (url, init)=>{
+        return loaderHooks.lifecycle.fetch.emit(url, init);
+    };
+    const res = await hook(input, init || {});
+    if (!res || !(res instanceof Response)) {
+        const fetchFunction = typeof fetch === 'undefined' ? await loadNodeFetch() : fetch;
+        return fetchFunction(input, init || {});
+    }
+    return res;
+};
+function createScriptNode(url, cb, attrs, createScriptHook) {
+    if (createScriptHook) {
+        const hookResult = createScriptHook(url);
+        if (hookResult && typeof hookResult === 'object' && '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 ()=>{
+        //@ts-ignore
+        if (typeof __webpack_require__ !== 'undefined') {
+            try {
+                //@ts-ignore
+                const loaderHooks = __webpack_require__.federation.instance.loaderHook;
+                if (loaderHooks.lifecycle.fetch) {
+                    return lazyLoaderHookFetch;
+                }
+            } catch (e) {
+                console.warn('federation.instance.loaderHook.lifecycle.fetch failed:', e);
+            }
+        }
+        return typeof fetch === 'undefined' ? 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);
+            var _vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER;
+            const script = new vm.Script(`(function(exports, module, require, __dirname, __filename) {${data}\n})`, {
+                filename,
+                importModuleDynamically: (_vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER = (_vm_constants = vm.constants) == null ? void 0 : _vm_constants.USE_MAIN_CONTEXT_DEFAULT_LOADER) != null ? _vm_constants_USE_MAIN_CONTEXT_DEFAULT_LOADER : importNodeModule
+            });
+            script.runInThisContext()(scriptContext.exports, scriptContext.module, eval('require'), urlDirname, filename);
+            const exportedInterface = scriptContext.module.exports || scriptContext.exports;
+            if (attrs && exportedInterface && attrs['globalName']) {
+                const container = exportedInterface[attrs['globalName']] || exportedInterface;
+                cb(undefined, container);
+                return;
+            }
+            cb(undefined, exportedInterface);
+        } catch (e) {
+            cb(e instanceof Error ? e : new Error(`Script execution error: ${e}`));
+        }
+    };
+    getFetch().then((f)=>handleScriptFetch(f, urlObj)).catch((err)=>{
+        cb(err);
+    });
+}
+function loadScriptNode(url, info) {
+    return new Promise((resolve, reject)=>{
+        createScriptNode(url, (error, scriptContext)=>{
+            if (error) {
+                reject(error);
+            } else {
+                var _info_attrs, _info_attrs1;
+                const remoteEntryKey = (info == null ? void 0 : (_info_attrs = info.attrs) == null ? void 0 : _info_attrs['globalName']) || `__FEDERATION_${info == null ? void 0 : (_info_attrs1 = info.attrs) == null ? void 0 : _info_attrs1['name']}:custom__`;
+                const entryExports = globalThis[remoteEntryKey] = scriptContext;
+                resolve(entryExports);
+            }
+        }, info.attrs, info.createScriptHook);
+    });
+}
+
+function normalizeOptions(enableDefault, defaultOptions, key) {
+    return function(options) {
+        if (options === false) {
+            return false;
+        }
+        if (typeof options === 'undefined') {
+            if (enableDefault) {
+                return defaultOptions;
+            } else {
+                return false;
+            }
+        }
+        if (options === true) {
+            return defaultOptions;
+        }
+        if (options && typeof options === 'object') {
+            return _extends({}, defaultOptions, options);
+        }
+        throw new Error(`Unexpected type for \`${key}\`, expect boolean/undefined/object, got: ${typeof options}`);
+    };
+}
+
+export { BROWSER_LOG_KEY, BROWSER_LOG_VALUE, ENCODE_NAME_PREFIX, EncodedNameTransformMap, FederationModuleManifest, Logger, MANIFEST_EXT, MFModuleType, MODULE_DEVTOOL_IDENTIFIER, ManifestFileName, NameTransformMap, NameTransformSymbol, SEPARATOR, StatsFileName, TEMP_DIR, assert, composeKeyWithSeparator, ContainerPlugin as containerPlugin, ContainerReferencePlugin as containerReferencePlugin, createLink, createScript, createScriptNode, decodeName, encodeName, error, generateExposeFilename, generateShareFilename, generateSnapshotFromManifest, getProcessEnv, getResourceUrl, inferAutoPublicPath, isBrowserEnv, isDebugMode, isManifestProvider, isStaticResourcesEqual, loadScript, loadScriptNode, logger, ModuleFederationPlugin as moduleFederationPlugin, normalizeOptions, parseEntry, safeWrapper, SharePlugin as sharePlugin, simpleJoinRemoteEntry, warn };