@module-federation/sdk 0.3.0 → 0.3.1

package/dist/index.cjs.js

@@ -0,0 +1,749 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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}`);
+    };
+}
+
+exports.BROWSER_LOG_KEY = BROWSER_LOG_KEY;
+exports.BROWSER_LOG_VALUE = BROWSER_LOG_VALUE;
+exports.ENCODE_NAME_PREFIX = ENCODE_NAME_PREFIX;
+exports.EncodedNameTransformMap = EncodedNameTransformMap;
+exports.FederationModuleManifest = FederationModuleManifest;
+exports.Logger = Logger;
+exports.MANIFEST_EXT = MANIFEST_EXT;
+exports.MFModuleType = MFModuleType;
+exports.MODULE_DEVTOOL_IDENTIFIER = MODULE_DEVTOOL_IDENTIFIER;
+exports.ManifestFileName = ManifestFileName;
+exports.NameTransformMap = NameTransformMap;
+exports.NameTransformSymbol = NameTransformSymbol;
+exports.SEPARATOR = SEPARATOR;
+exports.StatsFileName = StatsFileName;
+exports.TEMP_DIR = TEMP_DIR;
+exports.assert = assert;
+exports.composeKeyWithSeparator = composeKeyWithSeparator;
+exports.containerPlugin = ContainerPlugin;
+exports.containerReferencePlugin = ContainerReferencePlugin;
+exports.createLink = createLink;
+exports.createScript = createScript;
+exports.createScriptNode = createScriptNode;
+exports.decodeName = decodeName;
+exports.encodeName = encodeName;
+exports.error = error;
+exports.generateExposeFilename = generateExposeFilename;
+exports.generateShareFilename = generateShareFilename;
+exports.generateSnapshotFromManifest = generateSnapshotFromManifest;
+exports.getProcessEnv = getProcessEnv;
+exports.getResourceUrl = getResourceUrl;
+exports.inferAutoPublicPath = inferAutoPublicPath;
+exports.isBrowserEnv = isBrowserEnv;
+exports.isDebugMode = isDebugMode;
+exports.isManifestProvider = isManifestProvider;
+exports.isStaticResourcesEqual = isStaticResourcesEqual;
+exports.loadScript = loadScript;
+exports.loadScriptNode = loadScriptNode;
+exports.logger = logger;
+exports.moduleFederationPlugin = ModuleFederationPlugin;
+exports.normalizeOptions = normalizeOptions;
+exports.parseEntry = parseEntry;
+exports.safeWrapper = safeWrapper;
+exports.sharePlugin = SharePlugin;
+exports.simpleJoinRemoteEntry = simpleJoinRemoteEntry;
+exports.warn = warn;