Node.js模块处理机制

February 10, 2024November 24, 2024

本文不讨论具体的模块解析识和加载步骤，文档对此有详细描述。

CommonJS modules

require() 模块解析算法

CommonJS 模块执行前会被如下函数包装：（参见此处 Node.js 源码）

(function (
    exports: Module["exports"], // 指向 module.exports
    require: Require,
    module: Module, // 指向当前模块
    __filename: string,
    __dirname: string,
) {
    // 对 module.exports *同步*赋值，将值导出
    // module.exports 默认值是一个空对象，exports 仅当包装模块时是对这个对象的引用
    // 最终实际导出值是 module.exports，而不是 exports
});

为了验证之，测试 arguments 变量即可

// test.cjs
console.log(arguments);

require() 函数定义如下

interface Require {
    (id: string): any;
    resolve: RequireResolve;
    cache: Dict<NodeModule>;
    main: Module | undefined;
}

interface RequireResolve {
    (id: string, options?: { paths?: string[] | undefined }): string;
    paths(request: string): string[] | null;
}

interface Module {
    isPreloading: boolean;
    exports: any;
    require: Require;
    id: string;
    filename: string;
    loaded: boolean;
    children: Module[];
    path: string;
    paths: string[];
}

require() 函数对于相同输入 id，仅导入（执行）一次（在第一次时缓存，缓存到 require.cache 对象中），重复导入将得到相同的引用（在缓存 require.cache 中读取）。
注意 cjs 导入的结果是普通的 JavaScript 值，即导出和导入得到的值是相同的。（esm 则有不同）
此外 Node.js 内置模块都是可写的对象，这就允许它们被替换。而由于导入的是相同的引用，因此修改是立即可见的。

对于内置模块，如果不带 node: 前缀，也会尝试从 require.cache 中读取。
但若加上 node: 前缀则不会。因此 node: 前缀将保证能够获取到内置模块，但注意内置模块本身还是允许被修改的。

require("fs").write = (fd, str, cb) => {
    console.log(str + " <patched>");
};

require.cache.fs = {
    exports: {
        write() {
            console.log("fake!");
        },
    },
};

require.cache["node:fs"] = {
    exports: {
        write() {
            console.log("fake!");
        },
    },
};

// 确保得到内置模块，但内置模块本身允许被修改
const fs1 = require("node:fs");
fs1.write(1, "Hi, fs1", (err) => {}); // => Hi, fs1 <patched>

// 会先从缓存中读取
const fs2 = require("fs");
fs2.write(1, "Hi, fs2", (err) => {}); // => fake!

删除 require.cache 的键就可以令对应 id 重新加载导入

ECMAScript modules

ESM 模块除遵循语言规范外，还有 Node.js 的模块解析算法
另：mlly 库可能会有帮助

require() 导入的值与对应 module.exports 导出的值完全相同。
但在 ECMAScript 标准模块中，当导入整个模块作为一个对象时，得到是一个 Module 对象（module namespace object）。
该对象是普通的 JavaScript 对象，但其原型为 null，其 Symbol.toStringTag 键对应值为字符串 Module。
export 导出的对应键，在该对象中都是不可写的。

import * as m from "./esm.js";
const m = await import("./esm.js");

Object.getPrototypeOf(m) // => null

// m 相当于如下
{
    [Symbol.toStringTag]: 'Module'
    // ... 包含其它 export 导出的对应键
}

Node.js 模块的 ESM 导出，是命名导出所有 API，并将 CommonJS 导出值以 default 导出。
这种方式导出方式就很方便了，因为：

// 无需（当然也可以）
import * as fs from "fs";
// 只需（因为有 default 导出）
import fs from "fs";

以第一种导入方式时，根据 ESM 规范，该对象的键当然是不可写的。
第二种方式导入的相当于 require() 返回值，因此其键可写。

default 导出值就是 CommonJS 导出值。因此只有修改 default 导出值，才能在 ESM 环境中修改内置模块，
但需调用特殊的 syncBuiltinESMExports 函数，才能传播修改。

import fs, { readFileSync } from "node:fs";
import { syncBuiltinESMExports } from "node:module";
import { Buffer } from "node:buffer";

fs.readFileSync = () => Buffer.from("Hello, ESM");
syncBuiltinESMExports();

fs.readFileSync === readFileSync; // => true

对于我们自己编写的 CJS 模块，根据文档：
ESM 环境导入 CJS 模块时，module.exports 对象提供为 default 导出。为了更好的兼容性，会静态分析来提供命名导出。

ESM 与 CJS 互操性

Node.js 需要确定脚本是 ESM 还是 CJS，参见此处。需要注意 Node.js 对这些特性的支持版本。

ESM 环境没有 require 函数，通过以下方法得到：

import { createRequire } from "node:module";
const require = createRequire(import.meta.url);

目前，Node.js 已实验性支持通过 require() 加载 ES 模块
模块加载结果与 await import() 一致。限制条件为 ES 模块必须完全同步，即不含 top-level await

Typescript

moduleResolution 选项

module 选项决定编译器输出的模块类型，moduleResolution 决定如何解析输入的模块。

对于现代 Node.js 应用，使用 tsc 编译时，指定为 nodenext 即可。此时会仿照 Node.js 模块解析方式。
对于浏览器环境，往往真正是由其它 bundler 来解析依赖，因此指定为 bundler。此时允许省略文件名后缀。

allowSyntheticDefaultImports 和 esModuleInterop 选项

typescript 本身是根据 declaration 来识别导出的，这就可能导致 default 导入出现问题。

这些选项可处理此问题，具体参见handbook和对应文档。

bundler

在 ESM 规范中，import 不能省略文件名后缀（毕竟浏览器是网络请求，而不是本地文件系统），但很多 bundler 在解析 import 时并不会这么严格。

rollup

见 @rollup/plugin-commonjs 包 extensions 选项

webpack

见 resolve.extensions

esbuild

见 resolve extensions

CommonJS modules 实现

WIP

/lib/internal/modules/cjs/loader.js

/**
 * Create a new module instance.
 * @param {string} id
 * @param {Module} parent
 */
function Module(id = "", parent) {
    this.id = id;
    this.path = path.dirname(id);
    setOwnProperty(this, "exports", {});
    this[kModuleParent] = parent;
    updateChildren(parent, this, false);
    this.filename = null;
    this.loaded = false;
    this.children = [];
}

/** @type {Record<string, Module>} */
Module._cache = { __proto__: null };
/** @type {Record<string, string>} */
Module._pathCache = { __proto__: null };
/** @type {Record<string, (module: Module, filename: string) => void>} */
Module._extensions = { __proto__: null };
/** @type {string[]} */
let modulePaths = [];
/** @type {string[]} */
Module.globalPaths = [];

let patched = false;

/**
 * Add the CommonJS wrapper around a module's source code.
 * @param {string} script Module source code
 */
let wrap = function (script) {
    // eslint-disable-line func-style
    return Module.wrapper[0] + script + Module.wrapper[1];
};

const wrapper = ["(function (exports, require, module, __filename, __dirname) { ", "\n});"];

let wrapperProxy = new Proxy(wrapper, {
    __proto__: null,

    set(target, property, value, receiver) {
        patched = true;
        return ReflectSet(target, property, value, receiver);
    },

    defineProperty(target, property, descriptor) {
        patched = true;
        return ObjectDefineProperty(target, property, descriptor);
    },
});

ObjectDefineProperty(Module, "wrap", {
    __proto__: null,
    get() {
        return wrap;
    },

    set(value) {
        patched = true;
        wrap = value;
    },
});

ObjectDefineProperty(Module, "wrapper", {
    __proto__: null,
    get() {
        return wrapperProxy;
    },

    set(value) {
        patched = true;
        wrapperProxy = value;
    },
});

/lib/internal/modules/cjs/loader.js

/**
 * Wraps the given content in a script and runs it in a new context.
 * @param {string} filename The name of the file being loaded
 * @param {string} content The content of the file being loaded
 * @param {Module|undefined} cjsModuleInstance The CommonJS loader instance
 * @param {'commonjs'|undefined} format Intended format of the module.
 */
function wrapSafe(filename, content, cjsModuleInstance, format) {
    assert(format !== "module", "ESM should be handled in loadESMFromCJS()");
    const hostDefinedOptionId = vm_dynamic_import_default_internal;
    const importModuleDynamically = vm_dynamic_import_default_internal;
    if (patched) {
        const wrapped = Module.wrap(content);
        const script = makeContextifyScript(
            wrapped, // code
            filename, // filename
            0, // lineOffset
            0, // columnOffset
            undefined, // cachedData
            false, // produceCachedData
            undefined, // parsingContext
            hostDefinedOptionId, // hostDefinedOptionId
            importModuleDynamically, // importModuleDynamically
        );

        // Cache the source map for the module if present.
        const { sourceMapURL } = script;
        if (sourceMapURL) {
            maybeCacheSourceMap(filename, content, cjsModuleInstance, false, undefined, sourceMapURL);
        }

        return {
            __proto__: null,
            function: runScriptInThisContext(script, true, false), // 关键函数
            sourceMapURL,
        };
    }

    let shouldDetectModule = false;
    if (format !== "commonjs") {
        if (cjsModuleInstance?.[kIsMainSymbol]) {
            // For entry points, format detection is used unless explicitly disabled.
            shouldDetectModule = getOptionValue("--experimental-detect-module");
        } else {
            // For modules being loaded by `require()`, if require(esm) is disabled,
            // don't try to reparse to detect format and just throw for ESM syntax.
            shouldDetectModule = getOptionValue("--experimental-require-module");
        }
    }
    const result = compileFunctionForCJSLoader(content, filename, false /* is_sea_main */, shouldDetectModule);

    // Cache the source map for the module if present.
    if (result.sourceMapURL) {
        maybeCacheSourceMap(filename, content, cjsModuleInstance, false, undefined, result.sourceMapURL);
    }

    return result;
}

/**
 * Run the file contents in the correct scope or sandbox. Expose the correct helper variables (`require`, `module`,
 * `exports`) to the file. Returns exception, if any.
 * @param {string} content The source code of the module
 * @param {string} filename The file path of the module
 * @param {
 *    'module'|'commonjs'|'commonjs-typescript'|'module-typescript'
 * } format Intended format of the module.
 */
Module.prototype._compile = function (content, filename, format) {
    // 注：node22 通过 @swc/wasm-typescript 支持typescript，这里做类型擦除
    if (format === "commonjs-typescript" || format === "module-typescript" || format === "typescript") {
        content = stripTypeScriptModuleTypes(content, filename);
        switch (format) {
            case "commonjs-typescript": {
                format = "commonjs";
                break;
            }
            case "module-typescript": {
                format = "module";
                break;
            }
            // If the format is still unknown i.e. 'typescript', detect it in
            // wrapSafe using the type-stripped source.
            default:
                format = undefined;
                break;
        }
    }

    let redirects;

    let compiledWrapper;
    if (format !== "module") {
        // 默认当作 commonjs 执行
        // 通过 wrapSafe，将给定源码生成函数
        const result = wrapSafe(filename, content, this, format);
        compiledWrapper = result.function;
        if (result.canParseAsESM) {
            format = "module";
        }
    }

    if (format === "module") {
        loadESMFromCJS(this, filename, format, content);
        return;
    }

    // 创建包装函数所需参数
    const dirname = path.dirname(filename);
    const require = makeRequireFunction(this, redirects);
    let result;
    const exports = this.exports;
    const thisValue = exports;
    const module = this;
    if (requireDepth === 0) {
        statCache = new SafeMap();
    }
    setHasStartedUserCJSExecution();
    this[kIsExecuting] = true;
    if (this[kIsMainSymbol] && getOptionValue("--inspect-brk")) {
        const { callAndPauseOnStart } = internalBinding("inspector");
        result = callAndPauseOnStart(compiledWrapper, thisValue, exports, require, module, filename, dirname);
    } else {
        result = ReflectApply(compiledWrapper, thisValue, [exports, require, module, filename, dirname]);
    }
    this[kIsExecuting] = false;
    if (requireDepth === 0) {
        statCache = null;
    }
    return result;
};

/lib/internal/vm.js

/**
 * Runs a script in the current context.
 * Internal version of `vm.Script.prototype.runInThisContext()` which skips argument validation.
 * @param {ReturnType<makeContextifyScript>} script - The script to run.
 * @param {boolean} displayErrors - Whether to display errors.
 * @param {boolean} breakOnFirstLine - Whether to break on the first line.
 */
function runScriptInThisContext(script, displayErrors, breakOnFirstLine) {
    return ReflectApply(runInContext, script, [
        null, // sandbox - use current context
        -1, // timeout
        displayErrors, // displayErrors
        false, // breakOnSigint
        breakOnFirstLine, // breakOnFirstLine
    ]);
}

/lib/internal/vm.js

function runInContext(code, contextifiedObject, options) {
    validateContext(contextifiedObject);
    if (typeof options === "string") {
        options = {
            filename: options,
            [kParsingContext]: contextifiedObject,
        };
    } else {
        options = { ...options, [kParsingContext]: contextifiedObject };
    }
    return createScript(code, options).runInContext(contextifiedObject, options);
}

function createScript(code, options) {
    return new Script(code, options);
}

class Script extends ContextifyScript {
    // 省略
}

ContextifyScript 本质是一个 c++ 对象

cpp

class ContextifyScript final : CPPGC_MIXIN(ContextifyScript) {
 public:
  SET_CPPGC_NAME(ContextifyScript)
  void Trace(cppgc::Visitor* visitor) const final;

  ContextifyScript(Environment* env, v8::Local<v8::Object> object);
  ~ContextifyScript() override;

  v8::Local<v8::UnboundScript> unbound_script() const;
  void set_unbound_script(v8::Local<v8::UnboundScript>);

  static void CreatePerIsolateProperties(IsolateData* isolate_data,
                                         v8::Local<v8::ObjectTemplate> target);
  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
  static ContextifyScript* New(Environment* env, v8::Local<v8::Object> object);
  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
  static bool InstanceOf(Environment* env, const v8::Local<v8::Value>& args);
  static void CreateCachedData(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void RunInContext(const v8::FunctionCallbackInfo<v8::Value>& args);
  static bool EvalMachine(v8::Local<v8::Context> context,
                          Environment* env,
                          const int64_t timeout,
                          const bool display_errors,
                          const bool break_on_sigint,
                          const bool break_on_first_line,
                          v8::MicrotaskQueue* microtask_queue,
                          const v8::FunctionCallbackInfo<v8::Value>& args);

 private:
  v8::TracedReference<v8::UnboundScript> script_;
};

ECMAScript modules 实现

/lib/internal/modules/esm/loader.js

function createModuleLoader() {
    let customizations = null;
    // Don't spawn a new worker if custom loaders are disabled. For instance, if
    // we're already in a worker thread created by instantiating
    // CustomizedModuleLoader; doing so would cause an infinite loop.
    if (!forceDefaultLoader()) {
        const userLoaderPaths = getOptionValue("--experimental-loader");
        if (userLoaderPaths.length > 0) {
            if (!emittedLoaderFlagWarning) {
                const readableURIEncode = (string) =>
                    ArrayPrototypeReduce(
                        [
                            [/'/g, "%27"], // We need to URL-encode the single quote as it's the delimiter for the --import flag.
                            [/%22/g, '"'], // We can decode the double quotes to improve readability.
                            [/%2F/gi, "/"], // We can decode the slashes to improve readability.
                        ],
                        (str, { 0: regex, 1: replacement }) =>
                            RegExpPrototypeSymbolReplace(hardenRegExp(regex), str, replacement),
                        encodeURIComponent(string),
                    );
                process.emitWarning(
                    "`--experimental-loader` may be removed in the future; instead use `register()`:\n" +
                        `--import 'data:text/javascript,import { register } from "node:module"; import { pathToFileURL } from "node:url"; ${ArrayPrototypeJoin(
                            ArrayPrototypeMap(
                                userLoaderPaths,
                                (loader) =>
                                    `register(${readableURIEncode(JSONStringify(loader))}, pathToFileURL("./"))`,
                            ),
                            "; ",
                        )};'`,
                    "ExperimentalWarning",
                );
                emittedLoaderFlagWarning = true;
            }
            customizations = new CustomizedModuleLoader();
        }
    }

    return new ModuleLoader(customizations);
}

注册(Register): 可选步骤，用于注册自定义加载器。通过 module.exports.register 或命令行参数 --experimental-loader 实现。自定义加载器可以拦截和修改默认的加载流程。
解析(Resolve): 将模块标识符（specifier）解析为模块的 URL。核心函数包括：
- ModuleLoader.resolve(specifier, parentURL, importAttributes): 入口函数，处理自定义 resolve 钩子。
- ModuleLoader.resolveSync(specifier, parentURL, importAttributes): 同步版本，用于 import.meta.resolve 和在 CJS 中 require ESM。
- ModuleLoader.defaultResolve(originalSpecifier, parentURL, importAttributes): 默认的同步解析逻辑，如果没有自定义钩子则使用它。内部使用 internal/modules/esm/resolve.defaultResolve。
- ModuleLoader.#resolveAndMaybeBlockOnLoaderThread: 在同步解析中处理异步钩子，必要时阻塞主线程。
加载(Load): 根据解析得到的 URL 加载模块的源代码。核心函数包括：
- ModuleLoader.load(url, context): 入口函数，处理自定义 load 钩子。
- ModuleLoader.#loadSync(url, context): 同步版本，用于在 CJS 中 require ESM。
- ModuleLoader.#loadAndMaybeBlockOnLoaderThread: 在同步加载中处理异步钩子，必要时阻塞主线程。
- 默认加载函数：internal/modules/esm/load defaultLoad (异步) 和 internal/modules/esm/load defaultLoadSync (同步)。
翻译(Translate): 将加载的源代码转换为可执行的模块包装对象（ModuleWrap）。核心函数：
- ModuleLoader.#translate(url, format, source, isMain): 根据模块格式选择合适的翻译器进行转换。翻译器定义在 internal/modules/esm/translators 中。
实例化(Instantiate)和求值(Evaluate): 创建模块实例，执行模块代码，并将导出的值存储在命名空间对象中。核心类：
- ModuleJob: 异步加载和执行模块。
- ModuleJobSync: 同步加载和执行模块，用于在 CJS 中 require ESM。
定义在 /lib/internal/modules/esm/module_job.js
缓存(Cache): Node.js 会缓存已解析和加载的模块。ModuleLoader 的 resolveCache 和 loadCache 属性用于存储缓存结果。

/lib/internal/modules/esm/module_job.js

/**
 * This is a fully synchronous job and does not spawn additional threads in any way.
 * All the steps are ensured to be synchronous and it throws on instantiating
 * an asynchronous graph. It also disallows CJS <-> ESM cycles.
 *
 * This is used for ES modules loaded via require(esm). Modules loaded by require() in
 * imported CJS are handled by ModuleJob with the isForRequireInImportedCJS set to true instead.
 * The two currently have different caching behaviors.
 * TODO(joyeecheung): consolidate this with the isForRequireInImportedCJS variant of ModuleJob.
 */
class ModuleJobSync extends ModuleJobBase {
    #loader = null;

    /**
     * @param {ModuleLoader} loader The ESM loader.
     * @param {string} url URL of the module to be wrapped in ModuleJob.
     * @param {ImportAttributes} importAttributes Import attributes from the import statement.
     * @param {ModuleWrap} moduleWrap Translated ModuleWrap for the module.
     * @param {boolean} isMain Whether the module is the entry point.
     * @param {boolean} inspectBrk Whether this module should be evaluated with the
     *                             first line paused in the debugger (because --inspect-brk is passed).
     */
    constructor(loader, url, importAttributes, moduleWrap, isMain, inspectBrk) {
        super(url, importAttributes, isMain, inspectBrk, true);

        this.#loader = loader;
        this.module = moduleWrap;

        assert(this.module instanceof ModuleWrap);
        // Store itself into the cache first before linking in case there are circular
        // references in the linking.
        loader.loadCache.set(url, importAttributes.type, this);

        try {
            const moduleRequests = this.module.getModuleRequests();
            // Specifiers should be aligned with the moduleRequests array in order.
            const specifiers = Array(moduleRequests.length);
            const modules = Array(moduleRequests.length);
            const jobs = Array(moduleRequests.length);
            for (let i = 0; i < moduleRequests.length; ++i) {
                const { specifier, attributes } = moduleRequests[i];
                const job = this.#loader.getModuleJobForRequire(specifier, url, attributes);
                specifiers[i] = specifier;
                modules[i] = job.module;
                jobs[i] = job;
            }
            this.module.link(specifiers, modules);
            this.linked = jobs;
        } finally {
            // Restore it - if it succeeds, we'll reset in the caller; Otherwise it's
            // not cached and if the error is caught, subsequent attempt would still fail.
            loader.loadCache.delete(url, importAttributes.type);
        }
    }

    get modulePromise() {
        return PromiseResolve(this.module);
    }

    async run() {
        // This path is hit by a require'd module that is imported again.
        const status = this.module.getStatus();
        if (status > kInstantiated) {
            if (this.evaluationPromise) {
                await this.evaluationPromise;
            }
            return { __proto__: null, module: this.module };
        } else if (status === kInstantiated) {
            // The evaluation may have been canceled because instantiateSync() detected TLA first.
            // But when it is imported again, it's fine to re-evaluate it asynchronously.
            const timeout = -1;
            const breakOnSigint = false;
            this.evaluationPromise = this.module.evaluate(timeout, breakOnSigint);
            await this.evaluationPromise;
            this.evaluationPromise = undefined;
            return { __proto__: null, module: this.module };
        }

        assert.fail(
            "Unexpected status of a module that is imported again after being required. " + `Status = ${status}`,
        );
    }

    runSync() {
        // TODO(joyeecheung): add the error decoration logic from the async instantiate.
        this.module.async = this.module.instantiateSync();
        // If --experimental-print-required-tla is true, proceeds to evaluation even
        // if it's async because we want to search for the TLA and help users locate
        // them.
        // TODO(joyeecheung): track the asynchroniticy using v8::Module::HasTopLevelAwait()
        // and we'll be able to throw right after compilation of the modules, using acron
        // to find and print the TLA.
        if (this.module.async && !getOptionValue("--experimental-print-required-tla")) {
            throw new ERR_REQUIRE_ASYNC_MODULE();
        }
        setHasStartedUserESMExecution();
        const namespace = this.module.evaluateSync();
        return { __proto__: null, module: this.module, namespace };
    }
}

观察源码易知，ModuleWrap 是真正执行模块的类，本质是一个 c++ 对象

/src/module_wrap.h


class ModuleWrap : public BaseObject {
 public:
  enum InternalFields {
    kModuleSlot = BaseObject::kInternalFieldCount,
    kURLSlot,
    kSyntheticEvaluationStepsSlot,
    kContextObjectSlot,  // Object whose creation context is the target Context
    kInternalFieldCount
  };

  static void CreatePerIsolateProperties(IsolateData* isolate_data,
                                         v8::Local<v8::ObjectTemplate> target);
  static void CreatePerContextProperties(v8::Local<v8::Object> target,
                                         v8::Local<v8::Value> unused,
                                         v8::Local<v8::Context> context,
                                         void* priv);
  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
  static void HostInitializeImportMetaObjectCallback(
      v8::Local<v8::Context> context,
      v8::Local<v8::Module> module,
      v8::Local<v8::Object> meta);

  void MemoryInfo(MemoryTracker* tracker) const override {
    tracker->TrackField("resolve_cache", resolve_cache_);
  }

  v8::Local<v8::Context> context() const;
  v8::Maybe<bool> CheckUnsettledTopLevelAwait();

  SET_MEMORY_INFO_NAME(ModuleWrap)
  SET_SELF_SIZE(ModuleWrap)

  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
    // XXX: The garbage collection rules for ModuleWrap are *super* unclear.
    // Do these objects ever get GC'd? Are we just okay with leaking them?
    return true;
  }

  static v8::Local<v8::PrimitiveArray> GetHostDefinedOptions(
      v8::Isolate* isolate, v8::Local<v8::Symbol> symbol);

  // When user_cached_data is not std::nullopt, use the code cache if it's not
  // nullptr, otherwise don't use code cache.
  // TODO(joyeecheung): when it is std::nullopt, use on-disk cache
  // See: https://github.com/nodejs/node/issues/47472
  static v8::MaybeLocal<v8::Module> CompileSourceTextModule(
      Realm* realm,
      v8::Local<v8::String> source_text,
      v8::Local<v8::String> url,
      int line_offset,
      int column_offset,
      v8::Local<v8::PrimitiveArray> host_defined_options,
      std::optional<v8::ScriptCompiler::CachedData*> user_cached_data,
      bool* cache_rejected);

  static void CreateRequiredModuleFacade(
      const v8::FunctionCallbackInfo<v8::Value>& args);

 private:
  ModuleWrap(Realm* realm,
             v8::Local<v8::Object> object,
             v8::Local<v8::Module> module,
             v8::Local<v8::String> url,
             v8::Local<v8::Object> context_object,
             v8::Local<v8::Value> synthetic_evaluation_step);
  ~ModuleWrap() override;

  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GetModuleRequests(
      const v8::FunctionCallbackInfo<v8::Value>& args);
  static void InstantiateSync(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void EvaluateSync(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GetNamespaceSync(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void Link(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void Instantiate(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void Evaluate(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GetNamespace(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GetStatus(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void GetError(const v8::FunctionCallbackInfo<v8::Value>& args);

  static void SetImportModuleDynamicallyCallback(
      const v8::FunctionCallbackInfo<v8::Value>& args);
  static void SetInitializeImportMetaObjectCallback(
      const v8::FunctionCallbackInfo<v8::Value>& args);
  static v8::MaybeLocal<v8::Value> SyntheticModuleEvaluationStepsCallback(
      v8::Local<v8::Context> context, v8::Local<v8::Module> module);
  static void SetSyntheticExport(
      const v8::FunctionCallbackInfo<v8::Value>& args);
  static void CreateCachedData(const v8::FunctionCallbackInfo<v8::Value>& args);

  static v8::MaybeLocal<v8::Module> ResolveModuleCallback(
      v8::Local<v8::Context> context,
      v8::Local<v8::String> specifier,
      v8::Local<v8::FixedArray> import_attributes,
      v8::Local<v8::Module> referrer);
  static ModuleWrap* GetFromModule(node::Environment*, v8::Local<v8::Module>);

  v8::Global<v8::Module> module_;
  std::unordered_map<std::string, v8::Global<v8::Object>> resolve_cache_;
  contextify::ContextifyContext* contextify_context_ = nullptr;
  bool synthetic_ = false;
  int module_hash_;
};

内部模块机制

TODO

←Back to home

This work is licensed under CC BY-NC-SA 4.0