@umijs/mfsu 4.0.0-canary.20220429.2 → 4.0.0-canary.20220506.1

package/dist/depInfo.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepInfo = void 0;
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const moduleGraph_1 = require("./moduleGraph");
+class DepInfo {
+    constructor(opts) {
+        this.moduleGraph = new moduleGraph_1.ModuleGraph();
+        this.cacheDependency = {};
+        this.opts = opts;
+        this.cacheFilePath = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, 'MFSU_CACHE.json');
+    }
+    shouldBuild() {
+        if (!utils_1.lodash.isEqual(this.cacheDependency, this.opts.mfsu.opts.getCacheDependency())) {
+            return 'cacheDependency has changed';
+        }
+        if (this.moduleGraph.hasDepChanged()) {
+            return 'moduleGraph has changed';
+        }
+        return false;
+    }
+    snapshot() {
+        this.cacheDependency = this.opts.mfsu.opts.getCacheDependency();
+        this.moduleGraph.snapshotDeps();
+    }
+    loadCache() {
+        if ((0, fs_1.existsSync)(this.cacheFilePath)) {
+            utils_1.logger.info('MFSU restore cache');
+            const { cacheDependency, moduleGraph } = JSON.parse((0, fs_1.readFileSync)(this.cacheFilePath, 'utf-8'));
+            this.cacheDependency = cacheDependency;
+            this.moduleGraph.restore(moduleGraph);
+        }
+    }
+    writeCache() {
+        utils_1.fsExtra.mkdirpSync((0, path_1.dirname)(this.cacheFilePath));
+        const newContent = JSON.stringify({
+            cacheDependency: this.cacheDependency,
+            moduleGraph: this.moduleGraph.toJSON(),
+        }, null, 2);
+        if ((0, fs_1.existsSync)(this.cacheFilePath) &&
+            (0, fs_1.readFileSync)(this.cacheFilePath, 'utf-8') === newContent) {
+            return;
+        }
+        utils_1.logger.info('MFSU write cache');
+        (0, fs_1.writeFileSync)(this.cacheFilePath, newContent, 'utf-8');
+    }
+}
+exports.DepInfo = DepInfo;

package/dist/esbuildHandlers/autoCssModules.d.ts

@@ -0,0 +1,2 @@
+import { IEsbuildLoaderHandlerParams } from '../types';
+export declare function autoCssModulesHandler(opts: IEsbuildLoaderHandlerParams): string;

package/dist/esbuildHandlers/autoCssModules.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoCssModulesHandler = void 0;
+const utils_1 = require("@umijs/utils");
+const CSS_MODULES_QUERY = '?modules';
+const QUERY_LENGTH = CSS_MODULES_QUERY.length;
+function autoCssModulesHandler(opts) {
+    let { code } = opts;
+    let offset = 0;
+    opts.imports.forEach((i) => {
+        if (i.d < 0 && (0, utils_1.isStyleFile)({ filename: i.n })) {
+            // import x from './index.less'
+            //   => import x from '
+            const importSegment = code.substring(i.ss + offset, i.s + offset);
+            // is css module
+            if (~importSegment.indexOf(' from')) {
+                code = `${code.substring(0, i.e + offset)}${CSS_MODULES_QUERY}${code.substring(i.e + offset)}`;
+                offset += QUERY_LENGTH;
+            }
+        }
+    });
+    return code;
+}
+exports.autoCssModulesHandler = autoCssModulesHandler;

package/dist/esbuildHandlers/awaitImport/index.d.ts

@@ -0,0 +1,12 @@
+import type { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+interface IParams {
+    cache: Map<string, any>;
+    opts: any;
+}
+interface IOpts {
+    code: string;
+    imports: ImportSpecifier[];
+    filePath: string;
+}
+export default function getAwaitImportHandler(params: IParams): (opts: IOpts) => string;
+export {};

package/dist/esbuildHandlers/awaitImport/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const checkMatch_1 = require("../../babelPlugins/awaitImport/checkMatch");
+function getAwaitImportHandler(params) {
+    return function awaitImportHandler(opts) {
+        var _a, _b;
+        let offset = 0;
+        let { code } = opts;
+        const { filePath, imports } = opts;
+        imports.forEach((i) => {
+            if (!i.n)
+                return;
+            const isLazyImport = i.d > 0;
+            const from = i.n;
+            const { isMatch, replaceValue } = (0, checkMatch_1.checkMatch)({
+                cache: params.cache,
+                value: from,
+                opts: params.opts,
+                filename: filePath,
+            });
+            if (isMatch) {
+                // case: import x from './index.ts';
+                //       import('./index.ts');
+                // import x from '
+                // import(
+                const preSeg = code.substring(0, i.s + offset);
+                // ';
+                // );
+                const tailSeg = code.substring(i.e + offset);
+                const quote = isLazyImport ? '"' : '';
+                code = `${preSeg}${quote}${replaceValue}${quote}${tailSeg}`;
+                offset += replaceValue.length - from.length;
+            }
+        });
+        if (params.cache.has(filePath)) {
+            (_b = (_a = params.opts).onCollect) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                file: filePath,
+                data: params.cache.get(filePath),
+            });
+        }
+        return code;
+    };
+}
+exports.default = getAwaitImportHandler;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './esbuildHandlers/autoCssModules';
+export { esbuildLoader } from './loader/esbuild';
+export * from './mfsu';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esbuildLoader = void 0;
+__exportStar(require("./constants"), exports);
+__exportStar(require("./esbuildHandlers/autoCssModules"), exports);
+// for independent use `esbuild-loader`
+var esbuild_1 = require("./loader/esbuild");
+Object.defineProperty(exports, "esbuildLoader", { enumerable: true, get: function () { return esbuild_1.esbuildLoader; } });
+__exportStar(require("./mfsu"), exports);

package/dist/loader/esbuild.d.ts

@@ -0,0 +1,5 @@
+import type { LoaderContext } from 'webpack';
+import type { IEsbuildLoaderOpts } from '../types';
+declare function esbuildTranspiler(this: LoaderContext<IEsbuildLoaderOpts>, source: string): Promise<void>;
+export default esbuildTranspiler;
+export declare const esbuildLoader: string;

package/dist/loader/esbuild.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esbuildLoader = void 0;
+const es_module_lexer_1 = require("@umijs/bundler-utils/compiled/es-module-lexer");
+const esbuild_1 = require("@umijs/bundler-utils/compiled/esbuild");
+const path_1 = require("path");
+async function esbuildTranspiler(source) {
+    var _a;
+    const done = this.async();
+    const options = this.getOptions();
+    const { handler = [], implementation, ...otherOptions } = options;
+    const transform = (implementation === null || implementation === void 0 ? void 0 : implementation.transform) || esbuild_1.transform;
+    const filePath = this.resourcePath;
+    const ext = (0, path_1.extname)(filePath).slice(1);
+    const transformOptions = {
+        ...otherOptions,
+        target: (_a = options.target) !== null && _a !== void 0 ? _a : 'es2015',
+        loader: ext !== null && ext !== void 0 ? ext : 'js',
+        sourcemap: this.sourceMap,
+        sourcefile: filePath,
+    };
+    try {
+        let { code, map } = await transform(source, transformOptions);
+        if (handler.length) {
+            await es_module_lexer_1.init;
+            handler.forEach((handle) => {
+                const [imports, exports] = (0, es_module_lexer_1.parse)(code);
+                code = handle({ code, imports, exports, filePath });
+            });
+        }
+        done(null, code, map && JSON.parse(map));
+    }
+    catch (error) {
+        done(error);
+    }
+}
+exports.default = esbuildTranspiler;
+exports.esbuildLoader = __filename;

package/dist/mfsu.d.ts

@@ -0,0 +1,63 @@
+import type { NextFunction, Request, Response } from '@umijs/bundler-utils/compiled/express';
+import webpack, { Configuration } from 'webpack';
+import awaitImport from './babelPlugins/awaitImport/awaitImport';
+import { DepBuilder } from './depBuilder/depBuilder';
+import { DepInfo } from './depInfo';
+import { Mode } from './types';
+interface IOpts {
+    cwd?: string;
+    excludeNodeNatives?: boolean;
+    exportAllMembers?: Record<string, string[]>;
+    getCacheDependency?: Function;
+    onMFSUProgress?: Function;
+    mfName?: string;
+    mode?: Mode;
+    tmpBase?: string;
+    unMatchLibs?: string[];
+    runtimePublicPath?: boolean | string;
+    implementor: typeof webpack;
+    buildDepWithESBuild?: boolean;
+    depBuildConfig: any;
+}
+export declare class MFSU {
+    opts: IOpts;
+    alias: Record<string, string>;
+    externals: (Record<string, string> | Function)[];
+    depInfo: DepInfo;
+    depBuilder: DepBuilder;
+    depConfig: Configuration | null;
+    buildDepsAgain: boolean;
+    progress: any;
+    onProgress: Function;
+    publicPath: string;
+    constructor(opts: IOpts);
+    asyncImport(content: string): string;
+    setWebpackConfig(opts: {
+        config: Configuration;
+        depConfig: Configuration;
+    }): Promise<void>;
+    buildDeps(): Promise<void>;
+    getMiddlewares(): ((req: Request, res: Response, next: NextFunction) => void)[];
+    private getAwaitImportCollectOpts;
+    getBabelPlugins(): ({
+        onTransformDeps: () => void;
+        onCollect: ({ file, data, }: {
+            file: string;
+            data: {
+                unMatched: Set<{
+                    sourceValue: string;
+                }>;
+                matched: Set<{
+                    sourceValue: string;
+                }>;
+            };
+        }) => void;
+        exportAllMembers: Record<string, string[]> | undefined;
+        unMatchLibs: string[] | undefined;
+        remoteName: string | undefined;
+        alias: Record<string, string>;
+        externals: (Function | Record<string, string>)[];
+    } | typeof awaitImport)[][];
+    getEsbuildLoaderHandler(): any[];
+}
+export {};

package/dist/mfsu.js

@@ -0,0 +1,294 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MFSU = void 0;
+const bundler_utils_1 = require("@umijs/bundler-utils");
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const mrmime_1 = require("../compiled/mrmime");
+// @ts-ignore
+const webpack_virtual_modules_1 = __importDefault(require("../compiled/webpack-virtual-modules"));
+const awaitImport_1 = __importDefault(require("./babelPlugins/awaitImport/awaitImport"));
+const getRealPath_1 = require("./babelPlugins/awaitImport/getRealPath");
+const constants_1 = require("./constants");
+const dep_1 = require("./dep/dep");
+const depBuilder_1 = require("./depBuilder/depBuilder");
+const depInfo_1 = require("./depInfo");
+const awaitImport_2 = __importDefault(require("./esbuildHandlers/awaitImport"));
+const types_1 = require("./types");
+const makeArray_1 = require("./utils/makeArray");
+const buildDepPlugin_1 = require("./webpackPlugins/buildDepPlugin");
+class MFSU {
+    constructor(opts) {
+        this.alias = {};
+        this.externals = [];
+        this.depConfig = null;
+        this.buildDepsAgain = false;
+        this.progress = { done: false };
+        this.publicPath = '/';
+        this.opts = opts;
+        this.opts.mfName = this.opts.mfName || constants_1.DEFAULT_MF_NAME;
+        this.opts.tmpBase =
+            this.opts.tmpBase || (0, path_1.join)(process.cwd(), constants_1.DEFAULT_TMP_DIR_NAME);
+        this.opts.mode = this.opts.mode || types_1.Mode.development;
+        this.opts.getCacheDependency = this.opts.getCacheDependency || (() => ({}));
+        this.onProgress = (progress) => {
+            var _a, _b;
+            this.progress = {
+                ...this.progress,
+                ...progress,
+            };
+            (_b = (_a = this.opts).onMFSUProgress) === null || _b === void 0 ? void 0 : _b.call(_a, this.progress);
+        };
+        this.opts.cwd = this.opts.cwd || process.cwd();
+        this.depInfo = new depInfo_1.DepInfo({ mfsu: this });
+        this.depBuilder = new depBuilder_1.DepBuilder({ mfsu: this });
+        this.depInfo.loadCache();
+    }
+    // swc don't support top-level await
+    // ref: https://github.com/vercel/next.js/issues/31054
+    asyncImport(content) {
+        return `await import('${(0, utils_1.winPath)(content)}');`;
+        // return `(async () => await import('${content}'))();`;
+    }
+    async setWebpackConfig(opts) {
+        var _a;
+        const { mfName } = this.opts;
+        /**
+         * config
+         */
+        // set alias and externals with reference for babel plugin
+        Object.assign(this.alias, ((_a = opts.config.resolve) === null || _a === void 0 ? void 0 : _a.alias) || {});
+        this.externals.push(...(0, makeArray_1.makeArray)(opts.config.externals || []));
+        // entry
+        const entry = {};
+        const virtualModules = {};
+        // ensure entry object type
+        const entryObject = utils_1.lodash.isString(opts.config.entry)
+            ? { default: [opts.config.entry] }
+            : opts.config.entry;
+        (0, assert_1.default)(utils_1.lodash.isPlainObject(entryObject), `webpack config 'entry' value must be a string or an object.`);
+        for (const key of Object.keys(entryObject)) {
+            const virtualPath = `./mfsu-virtual-entry/${key}.js`;
+            const virtualContent = [];
+            let index = 1;
+            let hasDefaultExport = false;
+            const entryFiles = utils_1.lodash.isArray(entryObject[key])
+                ? entryObject[key]
+                : [entryObject[key]];
+            for (let entry of entryFiles) {
+                // ensure entry is a file
+                if ((0, fs_1.statSync)(entry).isDirectory()) {
+                    const realEntry = (0, utils_1.tryPaths)([
+                        (0, path_1.join)(entry, 'index.tsx'),
+                        (0, path_1.join)(entry, 'index.ts'),
+                    ]);
+                    (0, assert_1.default)(realEntry, `entry file not found, please configure the specific entry path. (e.g. 'src/index.tsx')`);
+                    entry = realEntry;
+                }
+                const content = (0, fs_1.readFileSync)(entry, 'utf-8');
+                const [_imports, exports] = await (0, bundler_utils_1.parseModule)({ content, path: entry });
+                if (exports.length) {
+                    virtualContent.push(`const k${index} = ${this.asyncImport(entry)}`);
+                    for (const exportName of exports) {
+                        if (exportName === 'default') {
+                            hasDefaultExport = true;
+                            virtualContent.push(`export default k${index}.${exportName}`);
+                        }
+                        else {
+                            virtualContent.push(`export const ${exportName} = k${index}.${exportName}`);
+                        }
+                    }
+                }
+                else {
+                    virtualContent.push(this.asyncImport(entry));
+                }
+                index += 1;
+            }
+            if (!hasDefaultExport) {
+                virtualContent.push(`export default 1;`);
+            }
+            virtualModules[virtualPath] = virtualContent.join('\n');
+            entry[key] = virtualPath;
+        }
+        opts.config.entry = entry;
+        // plugins
+        opts.config.plugins = opts.config.plugins || [];
+        // support publicPath auto
+        let publicPath = opts.config.output.publicPath;
+        if (publicPath === 'auto') {
+            publicPath = '/';
+        }
+        this.publicPath = publicPath;
+        opts.config.plugins.push(...[
+            new webpack_virtual_modules_1.default(virtualModules),
+            new this.opts.implementor.container.ModuleFederationPlugin({
+                name: '__',
+                remotes: {
+                    [mfName]: this.opts.runtimePublicPath
+                        ? // ref:
+                            // https://webpack.js.org/concepts/module-federation/#promise-based-dynamic-remotes
+                            `
+promise new Promise(resolve => {
+  const remoteUrlWithVersion = window.publicPath + '${constants_1.REMOTE_FILE_FULL}';
+  const script = document.createElement('script');
+  script.src = remoteUrlWithVersion;
+  script.onload = () => {
+    // the injected script has loaded and is available on window
+    // we can now resolve this Promise
+    const proxy = {
+      get: (request) => window['${mfName}'].get(request),
+      init: (arg) => {
+        try {
+          return window['${mfName}'].init(arg);
+        } catch(e) {
+          console.log('remote container already initialized');
+        }
+      }
+    }
+    resolve(proxy);
+  }
+  // inject this script with the src set to the versioned remoteEntry.js
+  document.head.appendChild(script);
+})
+                `.trimLeft()
+                        : `${mfName}@${publicPath}${constants_1.REMOTE_FILE_FULL}`,
+                },
+            }),
+            new buildDepPlugin_1.BuildDepPlugin({
+                onCompileDone: () => {
+                    if (this.depBuilder.isBuilding) {
+                        this.buildDepsAgain = true;
+                    }
+                    else {
+                        this.buildDeps()
+                            .then(() => {
+                            this.onProgress({
+                                done: true,
+                            });
+                        })
+                            .catch((e) => {
+                            utils_1.logger.error(e);
+                            this.onProgress({
+                                done: true,
+                            });
+                        });
+                    }
+                },
+            }),
+            // new WriteCachePlugin({
+            //   onWriteCache: lodash.debounce(() => {
+            //     this.depInfo.writeCache();
+            //   }, 300),
+            // }),
+        ]);
+        // ensure topLevelAwait enabled
+        utils_1.lodash.set(opts.config, 'experiments.topLevelAwait', true);
+        /**
+         * depConfig
+         */
+        this.depConfig = opts.depConfig;
+    }
+    async buildDeps() {
+        const shouldBuild = this.depInfo.shouldBuild();
+        if (!shouldBuild) {
+            utils_1.logger.info('MFSU skip buildDeps');
+            return;
+        }
+        this.depInfo.snapshot();
+        const deps = dep_1.Dep.buildDeps({
+            deps: this.depInfo.moduleGraph.depSnapshotModules,
+            cwd: this.opts.cwd,
+            mfsu: this,
+        });
+        utils_1.logger.info(`MFSU buildDeps since ${shouldBuild}`);
+        utils_1.logger.debug(deps.map((dep) => dep.file).join(', '));
+        await this.depBuilder.build({
+            deps,
+        });
+        // Write cache
+        this.depInfo.writeCache();
+        if (this.buildDepsAgain) {
+            utils_1.logger.info('MFSU buildDepsAgain');
+            this.buildDepsAgain = false;
+            this.buildDeps().catch((e) => {
+                utils_1.logger.error(e);
+            });
+        }
+    }
+    getMiddlewares() {
+        return [
+            (req, res, next) => {
+                const publicPath = this.publicPath;
+                const isMF = req.path.startsWith(`${publicPath}${constants_1.MF_VA_PREFIX}`) ||
+                    req.path.startsWith(`${publicPath}${constants_1.MF_DEP_PREFIX}`) ||
+                    req.path.startsWith(`${publicPath}${constants_1.MF_STATIC_PREFIX}`);
+                if (isMF) {
+                    this.depBuilder.onBuildComplete(() => {
+                        if (!req.path.includes(constants_1.REMOTE_FILE)) {
+                            res.setHeader('cache-control', 'max-age=31536000,immutable');
+                        }
+                        res.setHeader('content-type', (0, mrmime_1.lookup)((0, path_1.extname)(req.path)) || 'text/plain');
+                        const relativePath = req.path.replace(new RegExp(`^${publicPath}`), '/');
+                        const content = (0, fs_1.readFileSync)((0, path_1.join)(this.opts.tmpBase, relativePath));
+                        res.send(content);
+                    });
+                }
+                else {
+                    next();
+                }
+            },
+        ];
+    }
+    getAwaitImportCollectOpts() {
+        return {
+            onTransformDeps: () => { },
+            onCollect: ({ file, data, }) => {
+                this.depInfo.moduleGraph.onFileChange({
+                    file,
+                    // @ts-ignore
+                    deps: [
+                        ...Array.from(data.matched).map((item) => ({
+                            file: item.sourceValue,
+                            isDependency: true,
+                            version: dep_1.Dep.getDepVersion({
+                                dep: item.sourceValue,
+                                cwd: this.opts.cwd,
+                            }),
+                        })),
+                        ...Array.from(data.unMatched).map((item) => ({
+                            file: (0, getRealPath_1.getRealPath)({
+                                file,
+                                dep: item.sourceValue,
+                            }),
+                            isDependency: false,
+                        })),
+                    ],
+                });
+            },
+            exportAllMembers: this.opts.exportAllMembers,
+            unMatchLibs: this.opts.unMatchLibs,
+            remoteName: this.opts.mfName,
+            alias: this.alias,
+            externals: this.externals,
+        };
+    }
+    getBabelPlugins() {
+        return [[awaitImport_1.default, this.getAwaitImportCollectOpts()]];
+    }
+    getEsbuildLoaderHandler() {
+        const cache = new Map();
+        const checkOpts = this.getAwaitImportCollectOpts();
+        return [
+            (0, awaitImport_2.default)({
+                cache,
+                opts: checkOpts,
+            }),
+        ];
+    }
+}
+exports.MFSU = MFSU;

package/dist/moduleGraph.d.ts

@@ -0,0 +1,73 @@
+declare class ModuleNode {
+    file: string;
+    importers: Set<ModuleNode>;
+    importedModules: Set<ModuleNode>;
+    isDependency: boolean;
+    isRoot: boolean;
+    version: string | null;
+    constructor(file: string);
+}
+interface IDep {
+    file: string;
+    isDependency: boolean;
+    version?: string;
+}
+export declare class ModuleGraph {
+    fileToModules: Map<string, ModuleNode>;
+    depToModules: Map<string, ModuleNode>;
+    depSnapshotModules: Record<string, {
+        file: string;
+        version: string;
+    }>;
+    rootModules: Set<ModuleNode>;
+    constructor();
+    restore(data: {
+        roots: any;
+        fileModules: any;
+        depModules: any;
+        depSnapshotModules: any;
+    }): void;
+    toJSON(): {
+        roots: string[];
+        fileModules: Record<string, {
+            importedModules: string[];
+            isRoot?: boolean | undefined;
+        }>;
+        depModules: Record<string, {
+            version: string | null;
+        }>;
+        depSnapshotModules: Record<string, {
+            file: string;
+            version: string;
+        }>;
+    };
+    snapshotDeps(): void;
+    getDepsInfo(mods: Map<string, ModuleNode>): Record<string, {
+        file: string;
+        version: string;
+    }>;
+    getDepInfo(mod: ModuleNode): {
+        file: string;
+        version: string;
+    };
+    hasDepChanged(): boolean;
+    onFileChange(opts: {
+        file: string;
+        deps: IDep[];
+    }): void;
+    updateModule(opts: {
+        mod: ModuleNode;
+        deps: IDep[];
+    }): void;
+    addNode(opts: {
+        file: string;
+        isDependency: boolean;
+        importer: ModuleNode;
+        version?: string | null;
+    }): void;
+    deleteNode(opts: {
+        mod: ModuleNode;
+        importer: ModuleNode;
+    }): void;
+}
+export {};