@module-federation/esbuild 0.0.0-next-20240530210646 → 0.0.2

package/dist/plugin.esm.js

@@ -1,4 +1,4 @@
-import fs__default from 'fs';
+import fs__default, { promises } from 'fs';
 import { init, parse as parse$1 } from 'es-module-lexer';
 import { init as init$1, parse } from 'cjs-module-lexer';
 import { promisify } from 'util';
@@ -49,7 +49,7 @@ async function getExports(modulePath) {
     }
 }
 
-var version = "0.0.1";
+var version = "0.0.2";
 
 function _extends$1() {
     _extends$1 = Object.assign || function(target) {
@@ -505,7 +505,9 @@ const createContainerPlugin = (config)=>({
             const filter = new RegExp([
                 filename
             ].map((name)=>`${name}$`).join('|'));
-            const sharedExternals = new RegExp(Object.keys(config.shared || {}).map((name)=>`${name}$`).join('|'));
+            const hasShared = Object.keys(config.shared || {}).length;
+            const shared = Object.keys(config.shared || {}).map((name)=>`${name}$`).join('|');
+            const sharedExternals = new RegExp(shared);
             build.onResolve({
                 filter
             }, async (args)=>({
@@ -526,24 +528,11 @@ const createContainerPlugin = (config)=>({
                         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'
-            }, async (args)=>{
-                if (sharedExternals.test(args.path)) {
+            if (hasShared) {
+                build.onResolve({
+                    filter: sharedExternals
+                }, (args)=>{
+                    if (args.namespace === 'esm-shares') return null;
                     return {
                         path: args.path,
                         namespace: 'virtual-share-module',
@@ -552,9 +541,24 @@ const createContainerPlugin = (config)=>({
                             resolveDir: args.resolveDir
                         }
                     };
-                }
-                return undefined;
-            });
+                });
+                build.onResolve({
+                    filter: /.*/,
+                    namespace: 'esm-shares'
+                }, async (args)=>{
+                    if (sharedExternals.test(args.path)) {
+                        return {
+                            path: args.path,
+                            namespace: 'virtual-share-module',
+                            pluginData: {
+                                kind: args.kind,
+                                resolveDir: args.resolveDir
+                            }
+                        };
+                    }
+                    return undefined;
+                });
+            }
             build.onLoad({
                 filter,
                 namespace: 'container'
@@ -595,7 +599,7 @@ const buildFederationHost = (config)=>{
     return `
     import { init as initFederationHost } from "@module-federation/runtime";
 
-    export const createVirtualRemoteModule = (name, ref, exports) => {
+    const createVirtualRemoteModule = (name, ref, exports) => {
       const genExports = exports.map(e =>
         e === 'default'
           ? 'export default mfLsZJ92.default;'
@@ -646,14 +650,14 @@ const buildFederationHost = (config)=>{
       }
     });
 
-     const host = initFederationHost({
+     const mfHoZJ92 = initFederationHost({
       name: ${JSON.stringify(name)},
       remotes: ${remoteConfigs},
       shared: ${sharedConfig},
       plugins: [runtimePlugin()],
     });
 
-    await Promise.all(host.initializeSharing('default', 'version-first'));
+    await Promise.all(mfHoZJ92.initializeSharing('default', 'version-first'));
 
 
   `;
@@ -756,6 +760,331 @@ const linkRemotesPlugin = (config)=>({
         }
     });
 
+// simplified from acorn (MIT license)
+function isNewLine(code) {
+    return code === 10 || code === 13 || code === 0x2028 || code === 0x2029;
+}
+function codePointToString(ch) {
+    if (ch <= 0xffff) return String.fromCharCode(ch);
+    ch -= 0x10000;
+    return String.fromCharCode((ch >> 10) + 0xd800, (ch & 0x03ff) + 0xdc00);
+}
+class Lexer {
+    readString(input, pos) {
+        if (pos >= input.length) return null;
+        this.input = input;
+        this.pos = pos;
+        const quote = this.input.charCodeAt(pos);
+        if (!(quote === 34 || quote === 39)) return null;
+        let out = '';
+        let chunkStart = ++this.pos;
+        //eslint-disable-next-line no-constant-condition
+        while(true){
+            if (this.pos >= this.input.length) return null;
+            const ch = this.input.charCodeAt(this.pos);
+            if (ch === quote) break;
+            if (ch === 92) {
+                out += this.input.slice(chunkStart, this.pos);
+                const escaped = this.readEscapedChar();
+                if (escaped === null) return null;
+                out += escaped;
+                chunkStart = this.pos;
+            } else {
+                if (isNewLine(ch)) return null;
+                ++this.pos;
+            }
+        }
+        out += this.input.slice(chunkStart, this.pos++);
+        return out;
+    }
+    readEscapedChar() {
+        const ch = this.input.charCodeAt(++this.pos);
+        let code;
+        ++this.pos;
+        switch(ch){
+            case 110:
+                return '\n';
+            case 114:
+                return '\r';
+            case 120:
+                code = this.readHexChar(2);
+                if (code === null) return null;
+                return String.fromCharCode(code);
+            case 117:
+                code = this.readCodePoint();
+                if (code === null) return null;
+                return codePointToString(code);
+            case 116:
+                return '\t';
+            case 98:
+                return '\b';
+            case 118:
+                return '\u000b';
+            case 102:
+                return '\f';
+            //@ts-ignore
+            case 13:
+                if (this.input.charCodeAt(this.pos) === 10) {
+                    ++this.pos;
+                }
+            // fall through
+            case 10:
+                return '';
+            case 56:
+            case 57:
+                return null;
+            default:
+                if (ch >= 48 && ch <= 55) {
+                    const match = this.input.slice(this.pos - 1, this.pos + 2).match(/^[0-7]+/);
+                    if (match === null) return null;
+                    let octalStr = match[0];
+                    let octal = parseInt(octalStr, 8);
+                    if (octal > 255) {
+                        octalStr = octalStr.slice(0, -1);
+                        octal = parseInt(octalStr, 8);
+                    }
+                    this.pos += octalStr.length - 1;
+                    const nextCh = this.input.charCodeAt(this.pos);
+                    if (octalStr !== '0' || nextCh === 56 || nextCh === 57) return null;
+                    return String.fromCharCode(octal);
+                }
+                if (isNewLine(ch)) return '';
+                return String.fromCharCode(ch);
+        }
+    }
+    readInt(radix, len) {
+        const start = this.pos;
+        let total = 0;
+        for(let i = 0; i < len; ++i, ++this.pos){
+            const code = this.input.charCodeAt(this.pos);
+            let val;
+            if (code >= 97) {
+                val = code - 97 + 10;
+            } else if (code >= 65) {
+                val = code - 65 + 10;
+            } else if (code >= 48 && code <= 57) {
+                val = code - 48;
+            } else {
+                val = Infinity;
+            }
+            if (val >= radix) break;
+            total = total * radix + val;
+        }
+        if (this.pos === start || len != null && this.pos - start !== len) return null;
+        return total;
+    }
+    readHexChar(len) {
+        return this.readInt(16, len);
+    }
+    readCodePoint() {
+        const ch = this.input.charCodeAt(this.pos);
+        let code;
+        if (ch === 123) {
+            ++this.pos;
+            code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
+            ++this.pos;
+            if (code && code > 0x10ffff) return null;
+        } else {
+            code = this.readHexChar(4);
+        }
+        return code;
+    }
+    constructor(){
+        this.input = '';
+        this.pos = 0;
+    }
+}
+
+function orderedUniq(array) {
+    // prettier-ignore
+    const ret = [], visited = new Set();
+    for (const val of array)if (!visited.has(val)) visited.add(val), ret.push(val);
+    return ret;
+}
+function cachedReduce(array, reducer, s) {
+    // prettier-ignore
+    const cache = [
+        s
+    ];
+    let cacheLen = 1, last = s;
+    return (len)=>{
+        while(cacheLen <= len)cacheLen = cache.push(last = reducer(last, array[cacheLen - 1]));
+        return cache[len];
+    };
+}
+// from @rollup/pluginutils
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtin = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtin}`.split(' '));
+forbiddenIdentifiers.add('');
+const makeLegalIdentifier = function makeLegalIdentifier(str) {
+    let identifier = str.replace(/-(\w)/g, (_, letter)=>letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
+        identifier = `_${identifier}`;
+    }
+    return identifier || '_';
+};
+
+function commonjs({ filter = /\.c?js$/, transform = true, transformConfig, requireReturnsDefault = true, ignore } = {}) {
+    const init_cjs_module_lexer = transform ? import('cjs-module-lexer') : undefined;
+    const use_default_export = typeof requireReturnsDefault === 'function' ? requireReturnsDefault : (_path)=>requireReturnsDefault;
+    const is_ignored = typeof ignore === 'function' ? ignore : Array.isArray(ignore) ? (path)=>ignore.includes(path) : ()=>false;
+    return {
+        name: 'commonjs',
+        setup ({ onLoad, esbuild, initialOptions }) {
+            let esbuild_shim;
+            const require_esbuild = ()=>esbuild || esbuild_shim || (esbuild_shim = require('esbuild'));
+            const read = promises.readFile;
+            const lexer = new Lexer();
+            //@ts-ignore
+            onLoad({
+                filter: filter
+            }, async (args)=>{
+                let parseCJS;
+                if (init_cjs_module_lexer) {
+                    const { init, parse } = await init_cjs_module_lexer;
+                    await init();
+                    parseCJS = parse;
+                }
+                let contents;
+                try {
+                    //@ts-ignore
+                    contents = await read(args.path, 'utf8');
+                } catch (e) {
+                    return null;
+                }
+                const willTransform = transform === true || typeof transform === 'function' && transform(args.path);
+                let cjsExports;
+                try {
+                    if (parseCJS && willTransform) {
+                        // move sourcemap to the end of the transformed file
+                        const sourcemapIndex = contents.lastIndexOf('//# sourceMappingURL=');
+                        let sourcemap;
+                        if (sourcemapIndex !== -1) {
+                            sourcemap = contents.slice(sourcemapIndex);
+                            const sourcemapEnd = sourcemap.indexOf('\n');
+                            if (sourcemapEnd !== -1 && sourcemap.slice(sourcemapEnd + 1).trimStart().length > 0) {
+                                // if there's code after sourcemap, it is invalid, don't do this.
+                                sourcemap = undefined;
+                            } else {
+                                contents = contents.slice(0, sourcemapIndex);
+                            }
+                        }
+                        // transform commonjs to es modules, easy mode
+                        cjsExports = parseCJS(contents);
+                        let { behavior, exports, sideEffects } = typeof willTransform === 'object' ? willTransform : {};
+                        var _transformConfig_behavior;
+                        behavior != null ? behavior : behavior = (_transformConfig_behavior = transformConfig == null ? void 0 : transformConfig.behavior) != null ? _transformConfig_behavior : 'node';
+                        exports = orderedUniq(cjsExports.exports.concat(exports != null ? exports : []));
+                        var _transformConfig_sideEffects;
+                        sideEffects != null ? sideEffects : sideEffects = (_transformConfig_sideEffects = transformConfig == null ? void 0 : transformConfig.sideEffects) != null ? _transformConfig_sideEffects : true;
+                        let exportDefault = behavior === 'node' ? 'export default exports;' : 'export default exports.__esModule ? exports.default : exports;';
+                        let exportsMap = exports.map((e)=>[
+                                e,
+                                makeLegalIdentifier(e)
+                            ]);
+                        if (exportsMap.some(([e])=>e === 'default')) {
+                            if (behavior === 'node') {
+                                exportsMap = exportsMap.filter(([e])=>e !== 'default');
+                            } else {
+                                exportDefault = '';
+                            }
+                        }
+                        const reexports = cjsExports.reexports.map((e)=>`export * from ${JSON.stringify(e)};`).join('');
+                        let transformed;
+                        if (sideEffects === false) {
+                            transformed = [
+                                // make sure we don't manipulate the first line so that sourcemap is fine
+                                reexports + 'var mod, exports = /* @__PURE__ */ ((exports, module) => {' + contents,
+                                'return module.exports})((mod = { exports: {} }).exports, mod); ' + exportDefault
+                            ];
+                            if (exportsMap.length > 0) {
+                                for (const [e, name] of exportsMap){
+                                    transformed.push(`var ${name} = /* @__PURE__ */ (() => exports[${JSON.stringify(e)}])();`);
+                                }
+                                transformed.push(`export { ${exportsMap.map(([e, name])=>e === name ? e : `${name} as ${JSON.stringify(e)}`).join(', ')} };`);
+                            }
+                        } else {
+                            transformed = [
+                                reexports + 'var exports = {}, module = { exports }; {' + contents,
+                                '}; exports = module.exports; ' + exportDefault
+                            ];
+                            if (exportsMap.length > 0) {
+                                transformed.push(`var { ${exportsMap.map(([e, name])=>e === name ? e : `${JSON.stringify(e)}: ${name}`).join(', ')} } = exports;`, `export { ${exportsMap.map(([e, name])=>e === name ? e : `${name} as ${JSON.stringify(e)}`).join(', ')} };`);
+                            }
+                        }
+                        contents = transformed.join('\n') + (sourcemap ? '\n' + sourcemap : '');
+                    }
+                } catch (e) {
+                    return null;
+                }
+                function makeName(path) {
+                    let name = `__import_${makeLegalIdentifier(path)}`;
+                    if (contents.includes(name)) {
+                        let suffix = 2;
+                        while(contents.includes(`${name}${suffix}`))suffix++;
+                        name = `${name}${suffix}`;
+                    }
+                    return name;
+                }
+                let warnings;
+                try {
+                    ({ warnings } = await require_esbuild().transform(contents, {
+                        format: 'esm',
+                        logLevel: 'silent'
+                    }));
+                } catch (err) {
+                    ({ warnings } = err);
+                }
+                const lines = contents.split('\n');
+                const getOffset = cachedReduce(lines, (a, b)=>a + 1 + b.length, 0);
+                if (warnings && (warnings = warnings.filter((e)=>e.text.includes('"require" to "esm"'))).length) {
+                    const edits = [];
+                    let imports = [];
+                    for (const { location } of warnings){
+                        if (location === null) continue;
+                        const { line, lineText, column, length } = location;
+                        const leftBrace = column + length + 1;
+                        const path = lexer.readString(lineText, leftBrace);
+                        if (path === null || is_ignored(path)) continue;
+                        const rightBrace = lineText.indexOf(')', leftBrace + 2 + path.length) + 1;
+                        const name = makeName(path);
+                        let import_statement;
+                        if (use_default_export(path)) {
+                            import_statement = `import ${name} from ${JSON.stringify(path)};`;
+                        } else {
+                            import_statement = `import * as ${name} from ${JSON.stringify(path)};`;
+                        }
+                        const offset = getOffset(line - 1);
+                        edits.push([
+                            offset + column,
+                            offset + rightBrace,
+                            name
+                        ]);
+                        imports.push(import_statement);
+                    }
+                    if (imports.length === 0) return null;
+                    imports = orderedUniq(imports);
+                    let offset = 0;
+                    for (const [start, end, name] of edits){
+                        contents = contents.slice(0, start + offset) + name + contents.slice(end + offset);
+                        offset += name.length - (end - start);
+                    }
+                    // if we have transformed this module (i.e. having `cjsExports`), don't make the file commonjs
+                    contents = [
+                        ...imports,
+                        cjsExports ? 'exports;' : '',
+                        contents
+                    ].join('');
+                    return {
+                        contents
+                    };
+                }
+            });
+        }
+    };
+}
+
 function _extends() {
     _extends = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
@@ -789,36 +1118,32 @@ const cjsToEsmPlugin = {
             filter: /.*/,
             namespace: 'esm-shares'
         }, async (args)=>{
-            const { transform } = await new Function('return 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');
-            try {
-                const result = await transform(fileContent);
-                if (result) {
-                    const { code } = result;
-                    return {
-                        contents: code,
-                        loader: 'js',
-                        resolveDir: path__default.dirname(resolver),
-                        pluginData: _extends({}, args.pluginData, {
-                            path: resolver
-                        })
-                    };
-                }
-            } catch (e) {
-                return {
-                    contents: fileContent,
-                    loader: 'js',
-                    resolveDir: path__default.dirname(resolver),
-                    pluginData: _extends({}, args.pluginData, {
-                        path: resolver
+            var _build_initialOptions_external;
+            let esbuild_shim;
+            const require_esbuild = ()=>build.esbuild || esbuild_shim || (esbuild_shim = require('esbuild'));
+            const packageBuilder = await require_esbuild().build(_extends({}, build.initialOptions, {
+                external: (_build_initialOptions_external = build.initialOptions.external) == null ? void 0 : _build_initialOptions_external.filter((e)=>{
+                    if (e.includes('*')) {
+                        const prefix = e.split('*')[0];
+                        return !args.path.startsWith(prefix);
+                    }
+                    return e !== args.path;
+                }),
+                entryPoints: [
+                    args.path
+                ],
+                plugins: [
+                    commonjs({
+                        filter: /.*/
                     })
-                };
-            }
-            return undefined;
+                ],
+                write: false
+            }));
+            return {
+                contents: packageBuilder.outputFiles[0].text,
+                loader: 'js',
+                resolveDir: args.pluginData.resolveDir
+            };
         });
     }
 };

package/dist/src/adapters/lib/collect-exports.d.ts

@@ -1,2 +1,3 @@
 export declare const resolve: (arg1: string, arg2: string) => Promise<string | false | undefined>;
+export declare const resolvePackageJson: (packageName: string, callback: (err: Error | null, result?: string) => void) => Promise<void>;
 export declare function getExports(modulePath: string): Promise<string[]>;

package/dist/src/adapters/lib/commonjs.d.ts

@@ -0,0 +1,101 @@
+import type { Plugin } from 'esbuild';
+export interface CommonJSOptions {
+    /**
+     * The regexp passed to onLoad() to match commonjs files.
+     *
+     * @default /\.c?js$/
+     */
+    filter?: RegExp;
+    /**
+     * _Experimental_: Transform commonjs to es modules. You have to install
+     * `cjs-module-lexer` to let it work.
+     *
+     * When `true`, the plugin tries to wrap the commonjs module into:
+     *
+     * ```js
+     * var exports = {}, module = { exports };
+     * {
+     *   // ... original content ...
+     * }
+     * exports = module.exports;
+     * // the exported names are extracted by cjs-module-lexer
+     * export default exports;
+     * var { something, "a-b" as a_b } = exports;
+     * export { something, a_b as "a-b" };
+     * ```
+     *
+     * @default false
+     */
+    transform?: boolean | ((path: string) => boolean | TransformConfig | null | void);
+    /**
+     * _Experimental_: This options acts as a fallback of the `transform` option above.
+     */
+    transformConfig?: Pick<TransformConfig, 'behavior' | 'sideEffects'>;
+    /**
+     * Controls which style of import should be used. By default, it transforms:
+     *
+     * ```js
+     * // input
+     * const foo = require("foo")
+     * // output
+     * import foo from "foo"
+     * ```
+     *
+     * The above case is often correct when 'foo' is also a commonjs module.
+     * But if 'foo' has es module exports, it is better to use:
+     *
+     * ```js
+     * // output
+     * import * as foo from "foo"
+     * ```
+     *
+     * In which case you can set `requireReturnsDefault` to `false` to get the above output.
+     * Or use the callback style to control the behavior for each module.
+     *
+     * @default true
+     */
+    requireReturnsDefault?: boolean | ((path: string) => boolean);
+    /**
+     * Don't replace require("ignored-modules"). Note that this will cause
+     * esbuild generates the __require() wrapper which throw error at runtime.
+     */
+    ignore?: string[] | ((path: string) => boolean);
+}
+export interface TransformConfig {
+    /**
+     * If `"babel"`, it will check if there be `exports.__esModule`,
+     * then export `exports.default`. i.e. The wrapper code becomes:
+     *
+     * ```js
+     * export default exports.__esModule ? exports.default : exports;
+     * ```
+     *
+     * @default "node"
+     */
+    behavior?: 'babel' | 'node';
+    /**
+     * Also include these named exports if they aren't recognized automatically.
+     *
+     * @example ["something"]
+     */
+    exports?: string[];
+    /**
+     * If `false`, slightly change the result to make it side-effect free.
+     * But it doesn't actually remove many code. So you maybe not need this.
+     *
+     * ```js
+     * var mod;
+     * var exports = /\*#__PURE__*\/ ((exports, module) => {
+     *   // ... original content ...
+     *   return module.exports;
+     * })((mod = { exports: {} }).exports, mod);
+     * export default exports;
+     * var a_b = /\*#__PURE__*\/ (() => exports['a-b'])();
+     * var something = /\*#__PURE__*\/ (() => exports.something)();
+     * export { a_b as "a-b", something };
+     * ```
+     */
+    sideEffects?: boolean;
+}
+export declare function commonjs({ filter, transform, transformConfig, requireReturnsDefault, ignore, }?: CommonJSOptions): Plugin;
+export default commonjs;

package/dist/src/adapters/lib/lexer.d.ts

@@ -0,0 +1,9 @@
+export declare class Lexer {
+    input: string;
+    pos: number;
+    readString(input: string, pos: number): string | null;
+    readEscapedChar(): string | null;
+    readInt(radix: number, len: number): number | null;
+    readHexChar(len: number): number | null;
+    readCodePoint(): number | null;
+}

package/dist/src/adapters/lib/transform.d.ts

@@ -0,0 +1,8 @@
+interface TransformInput {
+    code: string;
+    importMap?: string;
+    filename: string;
+    target?: string;
+}
+export declare function transform(input: TransformInput): Promise<string>;
+export {};

package/dist/src/adapters/lib/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function orderedUniq<T>(array: T[]): T[];
+export declare function cachedReduce<S, T>(array: T[], reducer: (s: S, a: T) => S, s: S): (len: number) => S;
+export declare const makeLegalIdentifier: (str: string) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/esbuild",
-  "version": "0.0.0-next-20240530210646",
+  "version": "0.0.2",
   "author": "Zack Jackson (@ScriptedAlchemy)",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
@@ -51,20 +51,18 @@
   },
   "dependencies": {
     "enhanced-resolve": "^5.16.1",
-    "esm-cjs-lexer": "^0.10.0",
     "cjs-module-lexer": "^1.3.1",
-    "@chialab/cjs-to-esm": "^0.18.0",
     "es-module-lexer": "^1.5.3",
-    "@chialab/estransform": "^0.18.1",
     "json5": "^2.2.3",
     "@rollup/plugin-commonjs": "^22.0.2",
     "@rollup/plugin-node-resolve": "^13.3.0",
     "@rollup/plugin-replace": "^4.0.0",
     "rollup": "^2.79.0",
+    "@chialab/esbuild-plugin-commonjs": "^0.18.0",
+    "@hyrious/esbuild-plugin-commonjs": "^0.2.4",
     "rollup-plugin-node-externals": "^4.1.1",
     "esbuild": "^0.18.12",
     "npmlog": "^6.0.2",
-    "acorn": "^8.8.1",
-    "@module-federation/sdk": "0.1.16"
+    "@module-federation/sdk": "0.2.3"
   }
 }