@module-federation/esbuild 0.0.0-next-20240523224941

package/dist/esbuild.esm.js

@@ -0,0 +1,1086 @@
+import esbuild$1 from 'esbuild';
+import { rollup } from 'rollup';
+import pluginNodeResolve from '@rollup/plugin-node-resolve';
+import { externals } from 'rollup-plugin-node-externals';
+import fs__default from 'fs';
+import path__default from 'path';
+import commonjs from '@rollup/plugin-commonjs';
+import replace from '@rollup/plugin-replace';
+import 'acorn';
+import { promisify } from 'util';
+import enhancedResolve from 'enhanced-resolve';
+import * as moduleLexer from 'cjs-module-lexer';
+import { f as federationBuilder } from './federation-builder.esm.js';
+import 'npmlog';
+
+function getAugmentedNamespace(n) {
+    if (n.__esModule) return n;
+    var a = Object.defineProperty({}, '__esModule', {
+        value: true
+    });
+    Object.keys(n).forEach(function(k) {
+        var d = Object.getOwnPropertyDescriptor(n, k);
+        Object.defineProperty(a, k, d.get ? d : {
+            enumerable: true,
+            get: function get() {
+                return n[k];
+            }
+        });
+    });
+    return a;
+}
+
+const resolve = promisify(enhancedResolve.create({
+    mainFields: [
+        'browser',
+        'module',
+        'main'
+    ]
+}));
+let lexerInitialized = false;
+async function getExports(modulePath) {
+    if (!lexerInitialized) {
+        await moduleLexer.init();
+        lexerInitialized = true;
+    }
+    try {
+        const exports = [];
+        const paths = [];
+        const resolvedPath = await resolve(process.cwd(), modulePath);
+        if (typeof resolvedPath === 'string') {
+            paths.push(resolvedPath);
+        }
+        while(paths.length > 0){
+            const currentPath = paths.pop();
+            if (currentPath) {
+                const results = moduleLexer.parse(await fs__default.readFileSync(currentPath, 'utf8'));
+                exports.push(...results.exports);
+                for (const reexport of results.reexports){
+                    const resolvedPath = await resolve(path__default.dirname(currentPath), reexport);
+                    if (typeof resolvedPath === 'string') {
+                        paths.push(resolvedPath);
+                    }
+                }
+            }
+        }
+        /**
+     * 追加default
+     */ if (!exports.includes('default')) {
+            exports.push('default');
+        }
+        return exports;
+    } catch (e) {
+        console.log(e);
+        return [
+            'default'
+        ];
+    }
+}
+
+var version = "0.0.1";
+
+function _extends$2() {
+    _extends$2 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$2.apply(this, arguments);
+}
+const writeRemoteManifest = async (config, result)=>{
+    if (result.errors && result.errors.length > 0) {
+        console.warn('Build errors detected, skipping writeRemoteManifest.');
+        return;
+    }
+    let packageJson;
+    try {
+        const packageJsonPath = await resolve(process.cwd(), '/package.json') || '';
+        packageJson = require(packageJsonPath);
+    } catch (e) {
+        packageJson = {
+            name: config.name
+        };
+    }
+    const mfConfig = config;
+    var _process_env_NODE_ENV;
+    const envType = process.env['NODE_ENV'] === 'development' ? 'local' : (_process_env_NODE_ENV = process.env['NODE_ENV']) != null ? _process_env_NODE_ENV : '';
+    const publicPath = config.publicPath || 'auto';
+    let containerName = '';
+    const outputMap = Object.entries(result.metafile.outputs).reduce((acc, [chunkKey, chunkValue])=>{
+        const { entryPoint } = chunkValue;
+        const key = entryPoint || chunkKey;
+        if (key.startsWith('container:') && key.endsWith(mfConfig.filename)) {
+            containerName = key;
+        }
+        acc[key] = _extends$2({}, chunkValue, {
+            chunk: chunkKey
+        });
+        return acc;
+    }, {});
+    if (!outputMap[containerName]) return;
+    const outputMapWithoutExt = Object.entries(result.metafile.outputs).reduce((acc, [chunkKey, chunkValue])=>{
+        const { entryPoint } = chunkValue;
+        const key = entryPoint || chunkKey;
+        const trimKey = key.substring(0, key.lastIndexOf('.')) || key;
+        acc[trimKey] = _extends$2({}, chunkValue, {
+            chunk: chunkKey
+        });
+        return acc;
+    }, {});
+    const getChunks = (meta, outputMap)=>{
+        const assets = {
+            js: {
+                async: [],
+                sync: []
+            },
+            css: {
+                async: [],
+                sync: []
+            }
+        };
+        if (meta == null ? void 0 : meta.imports) {
+            meta.imports.forEach((imp)=>{
+                const importMeta = outputMap[imp.path];
+                if (importMeta && importMeta.kind !== 'dynamic-import') {
+                    const childAssets = getChunks(importMeta, outputMap);
+                    assets.js.async.push(...childAssets.js.async);
+                    assets.js.sync.push(...childAssets.js.sync);
+                    assets.css.async.push(...childAssets.css.async);
+                    assets.css.sync.push(...childAssets.css.sync);
+                }
+            });
+            const assetType = meta.chunk.endsWith('.js') ? 'js' : 'css';
+            const syncOrAsync = meta.kind === 'dynamic-import' ? 'async' : 'sync';
+            assets[assetType][syncOrAsync].push(meta.chunk);
+        }
+        return assets;
+    };
+    const shared = mfConfig.shared ? await Promise.all(Object.entries(mfConfig.shared).map(async ([pkg, config])=>{
+        const meta = outputMap['esm-shares:' + pkg];
+        const chunks = getChunks(meta, outputMap);
+        let { version } = config;
+        if (!version) {
+            try {
+                const packageJsonPath = await resolve(process.cwd(), `${pkg}/package.json`);
+                if (packageJsonPath) {
+                    version = JSON.parse(fs__default.readFileSync(packageJsonPath, 'utf-8')).version;
+                }
+            } catch (e) {
+                console.warn(`Can't resolve ${pkg} version automatically, consider setting "version" manually`);
+            }
+        }
+        return {
+            id: `${mfConfig.name}:${pkg}`,
+            name: pkg,
+            version: version || config.version,
+            singleton: config.singleton || false,
+            requiredVersion: config.requiredVersion || '*',
+            assets: chunks
+        };
+    })) : [];
+    const remotes = mfConfig.remotes ? Object.entries(mfConfig.remotes).map(([alias, remote])=>{
+        const [federationContainerName, entry] = remote.includes('@') ? remote.split('@') : [
+            alias,
+            remote
+        ];
+        return {
+            federationContainerName,
+            moduleName: '',
+            alias,
+            entry
+        };
+    }) : [];
+    const exposes = mfConfig.exposes ? await Promise.all(Object.entries(mfConfig.exposes).map(async ([expose, value])=>{
+        const exposedFound = outputMapWithoutExt[value.replace('./', '')];
+        const chunks = getChunks(exposedFound, outputMap);
+        return {
+            id: `${mfConfig.name}:${expose.replace(/^\.\//, '')}`,
+            name: expose.replace(/^\.\//, ''),
+            assets: chunks,
+            path: expose
+        };
+    })) : [];
+    const types = {
+        path: '',
+        name: '',
+        zip: '@mf-types.zip',
+        api: '@mf-types.d.ts'
+    };
+    var _packageJson_name;
+    const manifest = {
+        id: mfConfig.name,
+        name: mfConfig.name,
+        metaData: {
+            name: mfConfig.name,
+            type: 'app',
+            buildInfo: {
+                buildVersion: envType,
+                buildName: ((_packageJson_name = packageJson.name) != null ? _packageJson_name : 'default').replace(/[^a-zA-Z0-9]/g, '_')
+            },
+            remoteEntry: {
+                name: mfConfig.filename,
+                path: outputMap[containerName] ? path__default.dirname(outputMap[containerName].chunk) : '',
+                type: 'esm'
+            },
+            types,
+            globalName: mfConfig.name,
+            pluginVersion: version,
+            publicPath
+        },
+        shared,
+        remotes,
+        exposes
+    };
+    const manifestPath = path__default.join(path__default.dirname(outputMap[containerName].chunk), 'mf-manifest.json');
+    fs__default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+};
+
+const createContainerCode = `
+import bundler_runtime_base from '@module-federation/webpack-bundler-runtime';
+// import instantiatePatch from "./federation.js";
+
+const createContainer = (federationOptions) => {
+  // await instantiatePatch(federationOptions, true);
+  const {exposes, name, remotes = [], shared, plugins} = federationOptions;
+
+  const __webpack_modules__ = {
+    "./node_modules/.federation/entry.1f2288102e035e2ed66b2efaf60ad043.js": (module, __webpack_exports__, __webpack_require__) => {
+      __webpack_require__.r(__webpack_exports__);
+      const bundler_runtime = __webpack_require__.n(bundler_runtime_base);
+      const prevFederation = __webpack_require__.federation;
+      __webpack_require__.federation = {};
+      for (const key in bundler_runtime()) {
+        __webpack_require__.federation[key] = bundler_runtime()[key];
+      }
+      for (const key in prevFederation) {
+        __webpack_require__.federation[key] = prevFederation[key];
+      }
+      if (!__webpack_require__.federation.instance) {
+        const pluginsToAdd = plugins || [];
+        __webpack_require__.federation.initOptions.plugins = __webpack_require__.federation.initOptions.plugins ?
+          __webpack_require__.federation.initOptions.plugins.concat(pluginsToAdd) : pluginsToAdd;
+        __webpack_require__.federation.instance = __webpack_require__.federation.runtime.init(__webpack_require__.federation.initOptions);
+        if (__webpack_require__.federation.attachShareScopeMap) {
+          __webpack_require__.federation.attachShareScopeMap(__webpack_require__);
+        }
+        if (__webpack_require__.federation.installInitialConsumes) {
+          __webpack_require__.federation.installInitialConsumes();
+        }
+      }
+    },
+
+    "webpack/container/entry/createContainer": (module, exports, __webpack_require__) => {
+      const moduleMap = {};
+      for (const key in exposes) {
+        if (Object.prototype.hasOwnProperty.call(exposes, key)) {
+          moduleMap[key] = () => Promise.resolve(exposes[key]()).then(m => () => m);
+        }
+      }
+
+      const get = (module, getScope) => {
+        __webpack_require__.R = getScope;
+        getScope = (
+          __webpack_require__.o(moduleMap, module)
+            ? moduleMap[module]()
+            : Promise.resolve().then(() => {
+              throw new Error("Module '" + module + "' does not exist in container.");
+            })
+        );
+        __webpack_require__.R = undefined;
+        return getScope;
+      };
+      const init = (shareScope, initScope, remoteEntryInitOptions) => {
+        return __webpack_require__.federation.bundlerRuntime.initContainerEntry({
+          webpackRequire: __webpack_require__,
+          shareScope: shareScope,
+          initScope: initScope,
+          remoteEntryInitOptions: remoteEntryInitOptions,
+          shareScopeKey: "default"
+        });
+      };
+      __webpack_require__("./node_modules/.federation/entry.1f2288102e035e2ed66b2efaf60ad043.js");
+
+      // This exports getters to disallow modifications
+      __webpack_require__.d(exports, {
+        get: () => get,
+        init: () => init,
+        moduleMap: () => moduleMap,
+      });
+    }
+  };
+
+  const __webpack_module_cache__ = {};
+
+  const __webpack_require__ = (moduleId) => {
+    let cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    let module = __webpack_module_cache__[moduleId] = {
+      id: moduleId,
+      loaded: false,
+      exports: {}
+    };
+
+    const execOptions = {
+      id: moduleId,
+      module: module,
+      factory: __webpack_modules__[moduleId],
+      require: __webpack_require__
+    };
+    __webpack_require__.i.forEach(handler => {
+      handler(execOptions);
+    });
+    module = execOptions.module;
+    execOptions.factory.call(module.exports, module, module.exports, execOptions.require);
+
+    module.loaded = true;
+
+    return module.exports;
+  };
+
+  __webpack_require__.m = __webpack_modules__;
+  __webpack_require__.c = __webpack_module_cache__;
+  __webpack_require__.i = [];
+
+  if (!__webpack_require__.federation) {
+    __webpack_require__.federation = {
+      initOptions: {
+        "name": name,
+        "remotes": remotes.map(remote => ({
+          "type": remote.type,
+          "alias": remote.alias,
+          "name": remote.name,
+          "entry": remote.entry,
+          "shareScope": remote.shareScope || "default"
+        }))
+      },
+      chunkMatcher: () => true,
+      rootOutputDir: "",
+      initialConsumes: undefined,
+      bundlerRuntimeOptions: {}
+    };
+  }
+
+  __webpack_require__.n = (module) => {
+    const getter = module && module.__esModule ? () => module['default'] : () => module;
+    __webpack_require__.d(getter, {a: getter});
+    return getter;
+  };
+
+  __webpack_require__.d = (exports, definition) => {
+    for (const key in definition) {
+      if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+        Object.defineProperty(exports, key, {enumerable: true, get: definition[key]});
+      }
+    }
+  };
+
+  __webpack_require__.f = {};
+
+  __webpack_require__.g = (() => {
+    if (typeof globalThis === 'object') return globalThis;
+    try {
+      return this || new Function('return this')();
+    } catch (e) {
+      if (typeof window === 'object') return window;
+    }
+  })();
+
+  __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+
+  __webpack_require__.r = (exports) => {
+    if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+      Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
+    }
+    Object.defineProperty(exports, '__esModule', {value: true});
+  };
+
+  __webpack_require__.federation.initOptions.shared = shared;
+  __webpack_require__.S = {};
+  const initPromises = {};
+  const initTokens = {};
+  __webpack_require__.I = (name, initScope) => {
+    return __webpack_require__.federation.bundlerRuntime.I({
+      shareScopeName: name,
+      webpackRequire: __webpack_require__,
+      initPromises: initPromises,
+      initTokens: initTokens,
+      initScope: initScope,
+    });
+  };
+
+  const __webpack_exports__ = __webpack_require__("webpack/container/entry/createContainer");
+  const __webpack_exports__get = __webpack_exports__.get;
+  const __webpack_exports__init = __webpack_exports__.init;
+  const __webpack_exports__moduleMap = __webpack_exports__.moduleMap;
+  return __webpack_exports__;
+}`;
+
+//replace with createContainer from bundler runtime
+//@ts-ignore
+const buildContainerHost = ({ config })=>{
+    const { name, remotes = {}, shared = {}, exposes = {} } = config;
+    const remoteConfigs = Object.entries(remotes).map(([remoteAlias, remote])=>({
+            type: 'esm',
+            name: remoteAlias,
+            entry: remote.entry,
+            alias: remoteAlias
+        }));
+    const sharedConfig = Object.entries(shared).reduce((acc, [pkg, config])=>{
+        var _config_requiredVersion;
+        const version = ((_config_requiredVersion = config.requiredVersion) == null ? void 0 : _config_requiredVersion.replace(/^[^0-9]/, '')) || '';
+        acc += `${JSON.stringify(pkg)}: {
+      "package": "${pkg}",
+      "version": "${version}",
+      "scope": "default",
+      "get": async () => import('federationShare/${pkg}'),
+      "shareConfig": {
+        "singleton": ${config.singleton},
+        "requiredVersion": "${config.requiredVersion}",
+        "eager": ${config.eager},
+        "strictVersion": ${config.strictVersion}
+      }
+    },\n`;
+        return acc;
+    }, '{') + '}';
+    let exposesConfig = Object.entries(exposes).map(([exposeName, exposePath])=>`${JSON.stringify(exposeName)}: async () => await import('${exposePath}')`).join(',\n');
+    exposesConfig = `{${exposesConfig}}`;
+    const injectedContent = `
+    export const moduleMap = '__MODULE_MAP__';
+
+    function appendImportMap(importMap) {
+      const script = document.createElement('script');
+      script.type = 'importmap-shim';
+      script.innerHTML = JSON.stringify(importMap);
+      document.head.appendChild(script);
+    }
+
+    export const createVirtualRemoteModule = (name, ref, exports) => {
+      const genExports = exports.map(e =>
+        e === 'default' ? 'export default mfLsZJ92.default' : \`export const \${e} = mfLsZJ92[\${JSON.stringify(e)}];\`
+      ).join('');
+
+      const loadRef = \`const mfLsZJ92 = await container.loadRemote(\${JSON.stringify(ref)});\`;
+
+      return \`
+        const container = __FEDERATION__.__INSTANCES__.find(container => container.name === name) || __FEDERATION__.__INSTANCES__[0];
+        \${loadRef}
+        \${genExports}
+      \`;
+    };
+
+    function encodeInlineESM(code) {
+      const encodedCode = encodeURIComponent(code);
+      return \`data:text/javascript;charset=utf-8,\${encodedCode}\`;
+    }
+
+    const runtimePlugin = () => ({
+        name: 'import-maps-plugin',
+        async init(args) {
+            const remotePrefetch = args.options.remotes.map(async (remote) => {
+                if (remote.type === 'esm') {
+                    await import(remote.entry);
+                }
+            });
+
+
+            await Promise.all(remotePrefetch);
+
+console.log('module map',moduleMap);
+            const map = Object.keys(moduleMap).reduce((acc, expose) => {
+                const importMap = importShim.getImportMap().imports;
+                const key = args.origin.name + expose.replace('.', '');
+                if (!importMap[key]) {
+                    const encodedModule = encodeInlineESM(
+                        createVirtualRemoteModule(args.origin.name, key, moduleMap[expose].exports)
+                    );
+                    acc[key] = encodedModule;
+                }
+                return acc;
+            }, {});
+            await importShim.addImportMap({ imports: map });
+            console.log('final map', importShim.getImportMap());
+
+            return args;
+        }
+    });
+
+    const createdContainer = await createContainer({
+      name: ${JSON.stringify(name)},
+      exposes: ${exposesConfig},
+      remotes: ${JSON.stringify(remoteConfigs)},
+      shared: ${sharedConfig},
+      plugins: [runtimePlugin()],
+    });
+
+    export const get = createdContainer.get;
+    export const init = createdContainer.init;
+  `;
+    //replace with createContainer from bundler runtime - import it in the string as a dep etc
+    return [
+        createContainerCode,
+        injectedContent
+    ].join('\n');
+};
+const createContainerPlugin = (config)=>({
+        name: 'createContainer',
+        setup (build) {
+            const { externals, config: { filename } } = config;
+            const filter = new RegExp([
+                filename
+            ].map((name)=>`${name}$`).join('|'));
+            const sharedExternals = new RegExp(externals.map((name)=>`${name}$`).join('|'));
+            build.onResolve({
+                filter
+            }, async (args)=>({
+                    path: args.path,
+                    namespace: 'container',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            build.onResolve({
+                filter: /^federationShare/
+            }, async (args)=>({
+                    path: args.path.replace('federationShare/', ''),
+                    namespace: 'esm-shares',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            build.onResolve({
+                filter: sharedExternals
+            }, (args)=>{
+                if (args.namespace === 'esm-shares') return null;
+                return {
+                    path: args.path,
+                    namespace: 'virtual-share-module',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                };
+            });
+            build.onResolve({
+                filter: /.*/,
+                namespace: 'esm-shares'
+            }, (args)=>{
+                if (sharedExternals.test(args.path)) {
+                    return {
+                        path: args.path,
+                        namespace: 'virtual-share-module',
+                        pluginData: {
+                            kind: args.kind,
+                            resolveDir: args.resolveDir
+                        }
+                    };
+                }
+                return {
+                    path: args.path,
+                    namespace: 'esm-shares',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                };
+            });
+            build.onLoad({
+                filter,
+                namespace: 'container'
+            }, async (args)=>({
+                    contents: buildContainerHost(config),
+                    loader: 'js',
+                    resolveDir: args.pluginData.resolveDir
+                }));
+        }
+    });
+
+// Builds the federation host code
+const buildFederationHost = ()=>{
+    const { name, remotes, shared } = federationBuilder.config;
+    const remoteConfigs = remotes ? JSON.stringify(Object.entries(remotes).map(([remoteAlias, remote])=>({
+            name: remoteAlias,
+            entry: remote,
+            alias: remoteAlias,
+            type: 'esm'
+        }))) : '[]';
+    const sharedConfig = Object.entries(shared != null ? shared : {}).reduce((acc, [pkg, config])=>{
+        var _config_requiredVersion;
+        const version = ((_config_requiredVersion = config.requiredVersion) == null ? void 0 : _config_requiredVersion.replace(/^[^0-9]/, '')) || '';
+        acc += `${JSON.stringify(pkg)}: {
+      "package": "${pkg}",
+      "version": "${version}",
+      "scope": "default",
+      "get": async () => await import('federationShare/${pkg}'),
+      "shareConfig": {
+        "singleton": ${config.singleton},
+        "requiredVersion": "${config.requiredVersion}",
+        "eager": ${config.eager},
+        "strictVersion": ${config.strictVersion}
+      }
+    },\n`;
+        return acc;
+    }, '{') + '}';
+    return `
+    import { init as initFederationHost } from "@module-federation/runtime";
+
+    export const createVirtualRemoteModule = (name, ref, exports) => {
+      const genExports = exports.map(e =>
+        e === 'default'
+          ? 'export default mfLsZJ92.default;'
+          : \`export const \${e} = mfLsZJ92[\${JSON.stringify(e)}];\`
+      ).join('');
+
+      const loadRef = \`const mfLsZJ92 = await container.loadRemote(\${JSON.stringify(ref)});\`;
+
+      return \`
+        const container = __FEDERATION__.__INSTANCES__.find(container => container.name === name) || __FEDERATION__.__INSTANCES__[0];
+        \${loadRef}
+        \${genExports}
+      \`;
+    };
+
+    function encodeInlineESM(code) {
+      return 'data:text/javascript;charset=utf-8,' + encodeURIComponent(code);
+    }
+
+    const runtimePlugin = () => ({
+      name: 'import-maps-plugin',
+      async init(args) {
+        const remotePrefetch = args.options.remotes.map(async (remote) => {
+          console.log('remote', remote);
+          if (remote.type === 'esm') {
+            await import(remote.entry);
+          }
+        });
+
+        await Promise.all(remotePrefetch);
+        if (typeof moduleMap !== 'undefined') {
+          const map = Object.keys(moduleMap).reduce((acc, expose) => {
+            const importMap = importShim.getImportMap().imports;
+            const key = args.origin.name + expose.replace('.', '');
+            if (!importMap[key]) {
+              const encodedModule = encodeInlineESM(
+                createVirtualRemoteModule(args.origin.name, key, moduleMap[expose].exports)
+              );
+              acc[key] = encodedModule;
+            }
+            return acc;
+          }, {});
+
+          await importShim.addImportMap({ imports: map });
+        }
+
+        return args;
+      }
+    });
+
+     initFederationHost({
+      name: ${JSON.stringify(name)},
+      remotes: ${remoteConfigs},
+      shared: ${sharedConfig},
+      plugins: [runtimePlugin()],
+    });
+  `;
+};
+const initializeHostPlugin = {
+    name: 'host-initialization',
+    setup (build) {
+        build.onResolve({
+            filter: /federation-host/
+        }, (args)=>({
+                path: args.path,
+                namespace: 'federation-host',
+                pluginData: {
+                    kind: args.kind,
+                    resolveDir: args.resolveDir
+                }
+            }));
+        build.onLoad({
+            filter: /.*/,
+            namespace: 'federation-host'
+        }, async (args)=>({
+                contents: buildFederationHost(),
+                resolveDir: args.pluginData.resolveDir
+            }));
+        build.onLoad({
+            filter: /.*\.(ts|js|mjs)$/,
+            namespace: 'file'
+        }, async (args)=>{
+            if (!build.initialOptions.entryPoints.some((e)=>args.path.includes(e))) return;
+            const contents = await fs__default.promises.readFile(args.path, 'utf8');
+            return {
+                contents: buildFederationHost() + contents
+            };
+        });
+    }
+};
+
+// relys on import map since i dont know the named exports of a remote to return.
+const createVirtualRemoteModule = (name, ref)=>`
+export * from ${JSON.stringify('federationRemote/' + ref)}
+`;
+const linkRemotesPlugin = {
+    name: 'linkRemotes',
+    setup (build) {
+        //@ts-ignore
+        const remotes = federationBuilder.config.remotes || {};
+        const filter = new RegExp(Object.keys(remotes).reduce((acc, key)=>{
+            if (!key) return acc;
+            acc.push(`^${key}`);
+            return acc;
+        }, []).join('|'));
+        build.onResolve({
+            filter: filter
+        }, async (args)=>{
+            return {
+                path: args.path,
+                namespace: 'remote-module'
+            };
+        });
+        build.onResolve({
+            filter: /^federationRemote/
+        }, async (args)=>{
+            return {
+                path: args.path.replace('federationRemote/', ''),
+                external: true,
+                namespace: 'externals'
+            };
+        });
+        build.onLoad({
+            filter,
+            namespace: 'remote-module'
+        }, async (args)=>{
+            return {
+                contents: createVirtualRemoteModule(federationBuilder.config.name, args.path),
+                loader: 'js',
+                resolveDir: path__default.dirname(args.path)
+            };
+        });
+    }
+};
+
+function _extends$1() {
+    _extends$1 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$1.apply(this, arguments);
+}
+// Creates a virtual module for sharing dependencies
+const createVirtualShareModule = (name, ref, exports)=>`
+  const container = __FEDERATION__.__INSTANCES__.find(container => container.name === ${JSON.stringify(name)}) || __FEDERATION__.__INSTANCES__[0]
+
+  const mfLsZJ92 = await container.loadShare(${JSON.stringify(ref)})
+
+  ${exports.map((e)=>e === 'default' ? `export default mfLsZJ92.default` : `export const ${e} = mfLsZJ92[${JSON.stringify(e)}];`).join('\n')}
+`;
+// Plugin to initialize the federation host
+// Plugin to transform CommonJS modules to ESM
+const cjsToEsmPlugin = {
+    name: 'cjs-to-esm',
+    setup (build) {
+        build.onLoad({
+            filter: /.*/,
+            namespace: 'esm-shares'
+        }, async (args)=>{
+            const { transform } = await eval("import('@chialab/cjs-to-esm')");
+            const resolver = await resolve(args.pluginData.resolveDir, args.path);
+            if (typeof resolver !== 'string') {
+                throw new Error(`Unable to resolve path: ${args.path}`);
+            }
+            const fileContent = fs__default.readFileSync(resolver, 'utf-8');
+            const { code } = await transform(fileContent);
+            return {
+                contents: code,
+                loader: 'js',
+                resolveDir: path__default.dirname(resolver),
+                pluginData: _extends$1({}, args.pluginData, {
+                    path: resolver
+                })
+            };
+        });
+    }
+};
+// Plugin to link shared dependencies
+const linkSharedPlugin = {
+    name: 'linkShared',
+    setup (build) {
+        const filter = new RegExp(federationBuilder.externals.map((name)=>`${name}$`).join('|'));
+        build.onLoad({
+            filter,
+            namespace: 'virtual-share-module'
+        }, async (args)=>{
+            const exp = await getExports(args.path);
+            return {
+                contents: createVirtualShareModule(federationBuilder.config.name, args.path, exp),
+                loader: 'js',
+                resolveDir: path__default.dirname(args.path)
+            };
+        });
+    }
+};
+// Main module federation plugin
+const moduleFederationPlugin = (config)=>({
+        name: 'module-federation',
+        setup (build) {
+            build.initialOptions.metafile = true;
+            const pluginStack = [];
+            const remotes = Object.keys(federationBuilder.config.remotes || {}).length;
+            const shared = Object.keys(federationBuilder.config.shared || {}).length;
+            const exposes = Object.keys(federationBuilder.config.exposes || {}).length;
+            const entryPoints = build.initialOptions.entryPoints;
+            const filename = federationBuilder.config.filename || 'remoteEntry.js';
+            if (remotes) {
+                pluginStack.push(linkRemotesPlugin);
+            }
+            if (shared) {
+                pluginStack.push(linkSharedPlugin);
+            }
+            if (!entryPoints) {
+                build.initialOptions.entryPoints = [];
+            }
+            if (exposes) {
+                if (Array.isArray(entryPoints)) {
+                    //@ts-ignore
+                    entryPoints.push(filename);
+                } else if (entryPoints && typeof entryPoints === 'object') {
+                    entryPoints[filename] = filename;
+                } else {
+                    build.initialOptions.entryPoints = [
+                        filename
+                    ];
+                }
+            }
+            [
+                initializeHostPlugin,
+                createContainerPlugin(config),
+                cjsToEsmPlugin,
+                ...pluginStack
+            ].forEach((plugin)=>plugin.setup(build));
+            build.onEnd(async (result)=>{
+                if (!result.metafile) return;
+                if (exposes) {
+                    const exposedConfig = federationBuilder.config.exposes || {};
+                    const remoteFile = federationBuilder.config.filename;
+                    const exposedEntries = {};
+                    const outputMapWithoutExt = Object.entries(result.metafile.outputs).reduce((acc, [chunkKey, chunkValue])=>{
+                        //@ts-ignore
+                        const { entryPoint } = chunkValue;
+                        const key = entryPoint || chunkKey;
+                        const trimKey = key.substring(0, key.lastIndexOf('.')) || key;
+                        //@ts-ignore
+                        acc[trimKey] = _extends$1({}, chunkValue, {
+                            chunk: chunkKey
+                        });
+                        return acc;
+                    }, {});
+                    for (const [expose, value] of Object.entries(exposedConfig)){
+                        //@ts-ignore
+                        const exposedFound = outputMapWithoutExt[value.replace('./', '')];
+                        if (exposedFound) {
+                            exposedEntries[expose] = {
+                                entryPoint: exposedFound.entryPoint,
+                                exports: exposedFound.exports
+                            };
+                        }
+                    }
+                    for (const [outputPath, value] of Object.entries(result.metafile.outputs)){
+                        if (!value.entryPoint) continue;
+                        if (!value.entryPoint.startsWith('container:')) continue;
+                        if (!value.entryPoint.endsWith(remoteFile)) continue;
+                        const container = fs__default.readFileSync(outputPath, 'utf-8');
+                        const withExports = container.replace('"__MODULE_MAP__"', `${JSON.stringify(exposedEntries)}`).replace("'__MODULE_MAP__'", `${JSON.stringify(exposedEntries)}`);
+                        fs__default.writeFileSync(outputPath, withExports, 'utf-8');
+                    }
+                }
+                await writeRemoteManifest(federationBuilder.config, result);
+                console.log(`build ended with ${result.errors.length} errors`);
+            });
+        }
+    });
+
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+function createEsBuildAdapter(config) {
+    if (!config.compensateExports) {
+        config.compensateExports = [
+            new RegExp('/react/')
+        ];
+    }
+    return async (options)=>{
+        const { entryPoints, external, outdir, hash, packageInfos, name, plugins = [] } = options;
+        // TODO: Do we need to prepare packages anymore as esbuild has evolved?
+        for (const entryPoint of entryPoints){
+            const isPkg = entryPoint.fileName.includes('node_modules');
+            const pkgName = isPkg ? inferePkgName(entryPoint.fileName) : '';
+            const tmpFolder = `node_modules/.tmp/${pkgName}`;
+            if (isPkg) {
+                await prepareNodePackage(entryPoint.fileName, external, tmpFolder, config, !!options.dev, name);
+                entryPoint.fileName = tmpFolder;
+            }
+        }
+        const ctx = await esbuild$1.context({
+            entryPoints: entryPoints.map((ep)=>({
+                    in: ep.fileName,
+                    out: path__default.parse(ep.outName).name
+                })),
+            write: false,
+            outdir,
+            entryNames: '[name]',
+            external,
+            loader: config.loader,
+            bundle: true,
+            splitting: true,
+            sourcemap: options.dev,
+            minify: !options.dev,
+            format: 'esm',
+            target: [
+                'esnext'
+            ],
+            plugins: [
+                ...config.plugins,
+                ...plugins
+            ],
+            metafile: true,
+            define: {
+                MF_CURRENT_HOST: JSON.stringify(name)
+            }
+        });
+        const result = await ctx.rebuild();
+        result.outputFiles = result.outputFiles.reduce((acc, file, index)=>{
+            const sharedPack = packageInfos ? packageInfos[index] : null;
+            if (!sharedPack) {
+                acc.push(file);
+                return acc;
+            }
+            const fileName = path__default.basename(file.path);
+            const filePath = path__default.join(outdir, fileName);
+            const relative = path__default.relative(process.cwd(), file.path);
+            const metadata = result.metafile.outputs[relative];
+            const replc = filePath.replace(filePath, 'mf_' + fileName);
+            acc.push(_extends({}, file, {
+                path: replc
+            }));
+            const vm = createVirtualShareModule(name, sharedPack.packageName, metadata.exports);
+            acc.push(_extends({}, file, {
+                contents: vm
+            }));
+            return acc;
+        }, []);
+        const writtenFiles = writeResult(result, outdir);
+        ctx.dispose();
+        return writtenFiles.map((fileName)=>({
+                fileName
+            }));
+    };
+}
+function writeResult(result, outdir) {
+    const outputFiles = result.outputFiles || [];
+    const writtenFiles = [];
+    for (const outFile of outputFiles){
+        const fileName = path__default.basename(outFile.path);
+        const filePath = path__default.join(outdir, fileName);
+        fs__default.mkdirSync(path__default.dirname(filePath), {
+            recursive: true
+        });
+        fs__default.writeFileSync(filePath, outFile.contents);
+        writtenFiles.push(filePath);
+    }
+    return writtenFiles;
+}
+async function prepareNodePackage(entryPoint, external, tmpFolder, config, dev, name) {
+    if (config.fileReplacements) {
+        entryPoint = replaceEntryPoint(entryPoint, normalize(config.fileReplacements));
+    }
+    const env = dev ? 'development' : 'production';
+    const result = await rollup({
+        input: entryPoint,
+        plugins: [
+            commonjs(),
+            externals({
+                include: external
+            }),
+            pluginNodeResolve(),
+            replace({
+                true: true,
+                values: {
+                    'process.env.NODE_ENV': `"${env}"`,
+                    MF_CURRENT_HOST: JSON.stringify(name)
+                }
+            })
+        ]
+    });
+    await result.write({
+        format: 'esm',
+        file: tmpFolder,
+        sourcemap: dev,
+        exports: 'named'
+    });
+}
+function inferePkgName(entryPoint) {
+    return entryPoint.replace(/.*?node_modules/g, '').replace(/[^A-Za-z0-9.]/g, '_');
+}
+function normalize(config) {
+    const result = {};
+    for(const key in config){
+        if (typeof config[key] === 'string') {
+            result[key] = {
+                file: config[key]
+            };
+        } else {
+            result[key] = config[key];
+        }
+    }
+    return result;
+}
+function replaceEntryPoint(entryPoint, fileReplacements) {
+    entryPoint = entryPoint.replace(/\\/g, '/');
+    for(const key in fileReplacements){
+        entryPoint = entryPoint.replace(new RegExp(`${key}$`), fileReplacements[key].file);
+    }
+    return entryPoint;
+}
+
+var adapter = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	createEsBuildAdapter: createEsBuildAdapter,
+	getExports: getExports,
+	resolve: resolve,
+	moduleFederationPlugin: moduleFederationPlugin
+});
+
+var require$$0 = /*@__PURE__*/ getAugmentedNamespace(adapter);
+
+const Adapter = require$$0;
+var esbuild = Adapter;
+
+export { esbuild as default };