Provides general utility methods when interacting with instances of\nModule, the module variable often seen in CommonJS modules. Accessed\nvia import 'node:module' or require('node:module').
A list of the names of all modules provided by Node.js. Can be used to verify\nif a module is maintained by a third party or not.
\nNote: the list doesn't contain prefix-only modules like node:test.
module in this context isn't the same object that's provided\nby the module wrapper. To access it, require the Module module:
// module.mjs\n// In an ECMAScript module\nimport { builtinModules as builtin } from 'node:module';\n// module.cjs\n// In a CommonJS module\nconst builtin = require('node:module').builtinModules;\nThe following constants are returned as the status field in the object returned by\nmodule.enableCompileCache() to indicate the result of the attempt to enable the\nmodule compile cache.
| Constant | \nDescription | \n
|---|---|
ENABLED | \n \n Node.js has enabled the compile cache successfully. The directory used to store the\n compile cache will be returned in the directory field in the\n returned object.\n | \n
ALREADY_ENABLED | \n \n The compile cache has already been enabled before, either by a previous call to\n module.enableCompileCache(), or by the NODE_COMPILE_CACHE=dir\n environment variable. The directory used to store the\n compile cache will be returned in the directory field in the\n returned object.\n | \n
FAILED | \n \n Node.js fails to enable the compile cache. This can be caused by the lack of\n permission to use the specified directory, or various kinds of file system errors.\n The detail of the failure will be returned in the message field in the\n returned object.\n | \n
DISABLED | \n \n Node.js cannot enable the compile cache because the environment variable\n NODE_DISABLE_COMPILE_CACHE=1 has been set.\n | \n
import { createRequire } from 'node:module';\nconst require = createRequire(import.meta.url);\n\n// sibling-module.js is a CommonJS module.\nconst siblingModule = require('./sibling-module');\nEnable module compile cache in the current Node.js instance.
\nIf cacheDir is not specified, Node.js will either use the directory specified by the\nNODE_COMPILE_CACHE=dir environment variable if it's set, or use\npath.join(os.tmpdir(), 'node-compile-cache') otherwise. For general use cases, it's\nrecommended to call module.enableCompileCache() without specifying the cacheDir,\nso that the directory can be overridden by the NODE_COMPILE_CACHE environment\nvariable when necessary.
Since compile cache is supposed to be a quiet optimization that is not required for the\napplication to be functional, this method is designed to not throw any exception when the\ncompile cache cannot be enabled. Instead, it will return an object containing an error\nmessage in the message field to aid debugging.\nIf compile cache is enabled successfully, the directory field in the returned object\ncontains the path to the directory where the compile cache is stored. The status\nfield in the returned object would be one of the module.constants.compileCacheStatus\nvalues to indicate the result of the attempt to enable the module compile cache.
This method only affects the current Node.js instance. To enable it in child worker threads,\neither call this method in child worker threads too, or set the\nprocess.env.NODE_COMPILE_CACHE value to compile cache directory so the behavior can\nbe inherited into the child workers. The directory can be obtained either from the\ndirectory field returned by this method, or with module.getCompileCacheDir().
The module compile cache can be enabled either using the module.enableCompileCache()\nmethod or the NODE_COMPILE_CACHE=dir environment variable. After it is enabled,\nwhenever Node.js compiles a CommonJS or a ECMAScript Module, it will use on-disk\nV8 code cache persisted in the specified directory to speed up the compilation.\nThis may slow down the first load of a module graph, but subsequent loads of the same module\ngraph may get a significant speedup if the contents of the modules do not change.
To clean up the generated compile cache on disk, simply remove the cache directory. The cache\ndirectory will be recreated the next time the same directory is used for for compile cache\nstorage. To avoid filling up the disk with stale cache, it is recommended to use a directory\nunder the os.tmpdir(). If the compile cache is enabled by a call to\nmodule.enableCompileCache() without specifying the directory, Node.js will use\nthe NODE_COMPILE_CACHE=dir environment variable if it's set, or defaults\nto path.join(os.tmpdir(), 'node-compile-cache') otherwise. To locate the compile cache\ndirectory used by a running Node.js instance, use module.getCompileCacheDir().
Currently when using the compile cache with V8 JavaScript code coverage, the\ncoverage being collected by V8 may be less precise in functions that are\ndeserialized from the code cache. It's recommended to turn this off when\nrunning tests to generate precise coverage.
\nThe enabled module compile cache can be disabled by the NODE_DISABLE_COMPILE_CACHE=1\nenvironment variable. This can be useful when the compile cache leads to unexpected or\nundesired behaviors (e.g. less precise test coverage).
Compilation cache generated by one version of Node.js can not be reused by a different\nversion of Node.js. Cache generated by different versions of Node.js will be stored\nseparately if the same base directory is used to persist the cache, so they can co-exist.
\nAt the moment, when the compile cache is enabled and a module is loaded afresh, the\ncode cache is generated from the compiled code immediately, but will only be written\nto disk when the Node.js instance is about to exit. This is subject to change. The\nmodule.flushCompileCache() method can be used to ensure the accumulated code cache\nis flushed to disk in case the application wants to spawn other Node.js instances\nand let them share the cache long before the parent exits.
\n\nCaveat: Do not use this to try to determine module format. There are many things affecting\nthat determination; the
\ntypefield of package.json is the least definitive (ex file extension\nsupersedes it, and a loader hook supersedes that).
\n\nCaveat: This currently leverages only the built-in default resolver; if\n
\nresolvecustomization hooks are registered, they will not affect the resolution.\nThis may change in the future.
/path/to/project\n ├ packages/\n ├ bar/\n ├ bar.js\n └ package.json // name = '@foo/bar'\n └ qux/\n ├ node_modules/\n └ some-package/\n └ package.json // name = 'some-package'\n ├ qux.js\n └ package.json // name = '@foo/qux'\n ├ main.js\n └ package.json // name = '@foo'\n// /path/to/project/packages/bar/bar.js\nimport { findPackageJSON } from 'node:module';\n\nfindPackageJSON('..', import.meta.url);\n// '/path/to/project/package.json'\n// Same result when passing an absolute specifier instead:\nfindPackageJSON(new URL('../', import.meta.url));\nfindPackageJSON(import.meta.resolve('../'));\n\nfindPackageJSON('some-package', import.meta.url);\n// '/path/to/project/packages/bar/node_modules/some-package/package.json'\n// When passing an absolute specifier, you might get a different result if the\n// resolved module is inside a subfolder that has nested `package.json`.\nfindPackageJSON(import.meta.resolve('some-package'));\n// '/path/to/project/packages/bar/node_modules/some-package/some-subfolder/package.json'\n\nfindPackageJSON('@foo/qux', import.meta.url);\n// '/path/to/project/packages/qux/package.json'\n// /path/to/project/packages/bar/bar.js\nconst { findPackageJSON } = require('node:module');\nconst { pathToFileURL } = require('node:url');\nconst path = require('node:path');\n\nfindPackageJSON('..', __filename);\n// '/path/to/project/package.json'\n// Same result when passing an absolute specifier instead:\nfindPackageJSON(pathToFileURL(path.join(__dirname, '..')));\n\nfindPackageJSON('some-package', __filename);\n// '/path/to/project/packages/bar/node_modules/some-package/package.json'\n// When passing an absolute specifier, you might get a different result if the\n// resolved module is inside a subfolder that has nested `package.json`.\nfindPackageJSON(pathToFileURL(require.resolve('some-package')));\n// '/path/to/project/packages/bar/node_modules/some-package/some-subfolder/package.json'\n\nfindPackageJSON('@foo/qux', __filename);\n// '/path/to/project/packages/qux/package.json'\nimport { isBuiltin } from 'node:module';\nisBuiltin('node:fs'); // true\nisBuiltin('fs'); // true\nisBuiltin('wss'); // false\nRegister a module that exports hooks that customize Node.js module\nresolution and loading behavior. See Customization hooks.
\nThis feature requires --allow-worker if used with the Permission Model.
WARNING: The output of this function should not be considered stable across Node.js versions,\ndue to changes in the TypeScript parser.
\nimport { stripTypeScriptTypes } from 'node:module';\nconst code = 'const a: number = 1;';\nconst strippedCode = stripTypeScriptTypes(code);\nconsole.log(strippedCode);\n// Prints: const a = 1;\nconst { stripTypeScriptTypes } = require('node:module');\nconst code = 'const a: number = 1;';\nconst strippedCode = stripTypeScriptTypes(code);\nconsole.log(strippedCode);\n// Prints: const a = 1;\nIf sourceUrl is provided, it will be used appended as a comment at the end of the output:
import { stripTypeScriptTypes } from 'node:module';\nconst code = 'const a: number = 1;';\nconst strippedCode = stripTypeScriptTypes(code, { mode: 'strip', sourceUrl: 'source.ts' });\nconsole.log(strippedCode);\n// Prints: const a = 1\\n\\n//# sourceURL=source.ts;\nconst { stripTypeScriptTypes } = require('node:module');\nconst code = 'const a: number = 1;';\nconst strippedCode = stripTypeScriptTypes(code, { mode: 'strip', sourceUrl: 'source.ts' });\nconsole.log(strippedCode);\n// Prints: const a = 1\\n\\n//# sourceURL=source.ts;\nWhen mode is 'transform', the code is transformed to JavaScript:
import { stripTypeScriptTypes } from 'node:module';\nconst code = `\n namespace MathUtil {\n export const add = (a: number, b: number) => a + b;\n }`;\nconst strippedCode = stripTypeScriptTypes(code, { mode: 'transform', sourceMap: true });\nconsole.log(strippedCode);\n// Prints:\n// var MathUtil;\n// (function(MathUtil) {\n// MathUtil.add = (a, b)=>a + b;\n// })(MathUtil || (MathUtil = {}));\n// # sourceMappingURL=data:application/json;base64, ...\nconst { stripTypeScriptTypes } = require('node:module');\nconst code = `\n namespace MathUtil {\n export const add = (a: number, b: number) => a + b;\n }`;\nconst strippedCode = stripTypeScriptTypes(code, { mode: 'transform', sourceMap: true });\nconsole.log(strippedCode);\n// Prints:\n// var MathUtil;\n// (function(MathUtil) {\n// MathUtil.add = (a, b)=>a + b;\n// })(MathUtil || (MathUtil = {}));\n// # sourceMappingURL=data:application/json;base64, ...\nThe module.syncBuiltinESMExports() method updates all the live bindings for\nbuiltin ES Modules to match the properties of the CommonJS exports. It\ndoes not add or remove exported names from the ES Modules.
const fs = require('node:fs');\nconst assert = require('node:assert');\nconst { syncBuiltinESMExports } = require('node:module');\n\nfs.readFile = newAPI;\n\ndelete fs.readFileSync;\n\nfunction newAPI() {\n // ...\n}\n\nfs.newAPI = newAPI;\n\nsyncBuiltinESMExports();\n\nimport('node:fs').then((esmFS) => {\n // It syncs the existing readFile property with the new value\n assert.strictEqual(esmFS.readFile, newAPI);\n // readFileSync has been deleted from the required fs\n assert.strictEqual('readFileSync' in fs, false);\n // syncBuiltinESMExports() does not remove readFileSync from esmFS\n assert.strictEqual('readFileSync' in esmFS, true);\n // syncBuiltinESMExports() does not add names\n assert.strictEqual(esmFS.newAPI, undefined);\n});\nThe module compile cache can be enabled either using the module.enableCompileCache()\nmethod or the NODE_COMPILE_CACHE=dir environment variable. After it is enabled,\nwhenever Node.js compiles a CommonJS or a ECMAScript Module, it will use on-disk\nV8 code cache persisted in the specified directory to speed up the compilation.\nThis may slow down the first load of a module graph, but subsequent loads of the same module\ngraph may get a significant speedup if the contents of the modules do not change.
To clean up the generated compile cache on disk, simply remove the cache directory. The cache\ndirectory will be recreated the next time the same directory is used for for compile cache\nstorage. To avoid filling up the disk with stale cache, it is recommended to use a directory\nunder the os.tmpdir(). If the compile cache is enabled by a call to\nmodule.enableCompileCache() without specifying the directory, Node.js will use\nthe NODE_COMPILE_CACHE=dir environment variable if it's set, or defaults\nto path.join(os.tmpdir(), 'node-compile-cache') otherwise. To locate the compile cache\ndirectory used by a running Node.js instance, use module.getCompileCacheDir().
Currently when using the compile cache with V8 JavaScript code coverage, the\ncoverage being collected by V8 may be less precise in functions that are\ndeserialized from the code cache. It's recommended to turn this off when\nrunning tests to generate precise coverage.
\nThe enabled module compile cache can be disabled by the NODE_DISABLE_COMPILE_CACHE=1\nenvironment variable. This can be useful when the compile cache leads to unexpected or\nundesired behaviors (e.g. less precise test coverage).
Compilation cache generated by one version of Node.js can not be reused by a different\nversion of Node.js. Cache generated by different versions of Node.js will be stored\nseparately if the same base directory is used to persist the cache, so they can co-exist.
\nAt the moment, when the compile cache is enabled and a module is loaded afresh, the\ncode cache is generated from the compiled code immediately, but will only be written\nto disk when the Node.js instance is about to exit. This is subject to change. The\nmodule.flushCompileCache() method can be used to ensure the accumulated code cache\nis flushed to disk in case the application wants to spawn other Node.js instances\nand let them share the cache long before the parent exits.
The following constants are returned as the status field in the object returned by\nmodule.enableCompileCache() to indicate the result of the attempt to enable the\nmodule compile cache.
| Constant | \nDescription | \n
|---|---|
ENABLED | \n \n Node.js has enabled the compile cache successfully. The directory used to store the\n compile cache will be returned in the directory field in the\n returned object.\n | \n
ALREADY_ENABLED | \n \n The compile cache has already been enabled before, either by a previous call to\n module.enableCompileCache(), or by the NODE_COMPILE_CACHE=dir\n environment variable. The directory used to store the\n compile cache will be returned in the directory field in the\n returned object.\n | \n
FAILED | \n \n Node.js fails to enable the compile cache. This can be caused by the lack of\n permission to use the specified directory, or various kinds of file system errors.\n The detail of the failure will be returned in the message field in the\n returned object.\n | \n
DISABLED | \n \n Node.js cannot enable the compile cache because the environment variable\n NODE_DISABLE_COMPILE_CACHE=1 has been set.\n | \n
Enable module compile cache in the current Node.js instance.
\nIf cacheDir is not specified, Node.js will either use the directory specified by the\nNODE_COMPILE_CACHE=dir environment variable if it's set, or use\npath.join(os.tmpdir(), 'node-compile-cache') otherwise. For general use cases, it's\nrecommended to call module.enableCompileCache() without specifying the cacheDir,\nso that the directory can be overridden by the NODE_COMPILE_CACHE environment\nvariable when necessary.
Since compile cache is supposed to be a quiet optimization that is not required for the\napplication to be functional, this method is designed to not throw any exception when the\ncompile cache cannot be enabled. Instead, it will return an object containing an error\nmessage in the message field to aid debugging.\nIf compile cache is enabled successfully, the directory field in the returned object\ncontains the path to the directory where the compile cache is stored. The status\nfield in the returned object would be one of the module.constants.compileCacheStatus\nvalues to indicate the result of the attempt to enable the module compile cache.
This method only affects the current Node.js instance. To enable it in child worker threads,\neither call this method in child worker threads too, or set the\nprocess.env.NODE_COMPILE_CACHE value to compile cache directory so the behavior can\nbe inherited into the child workers. The directory can be obtained either from the\ndirectory field returned by this method, or with module.getCompileCacheDir().
Flush the module compile cache accumulated from modules already loaded\nin the current Node.js instance to disk. This returns after all the flushing\nfile system operations come to an end, no matter they succeed or not. If there\nare any errors, this will fail silently, since compile cache misses should not\ninterfere with the actual operation of the application.
" }, { "textRaw": "`module.getCompileCacheDir()`", "type": "method", "name": "getCompileCacheDir", "meta": { "added": [ "v22.8.0" ], "changes": [] }, "stability": 1, "stabilityText": ".1 - Active Development", "signatures": [ { "return": { "textRaw": "Returns: {string|undefined} Path to the [module compile cache][] directory if it is enabled, or `undefined` otherwise.", "name": "return", "type": "string|undefined", "desc": "Path to the [module compile cache][] directory if it is enabled, or `undefined` otherwise." }, "params": [] } ], "desc": "" } ], "type": "module", "displayName": "Module compile cache" }, { "textRaw": "Source map v3 support", "name": "source_map_v3_support", "meta": { "added": [ "v13.7.0", "v12.17.0" ], "changes": [] }, "stability": 1, "stabilityText": "Experimental", "desc": "
Helpers for interacting with the source map cache. This cache is\npopulated when source map parsing is enabled and\nsource map include directives are found in a modules' footer.
\nTo enable source map parsing, Node.js must be run with the flag\n--enable-source-maps, or with code coverage enabled by setting\nNODE_V8_COVERAGE=dir.
// module.mjs\n// In an ECMAScript module\nimport { findSourceMap, SourceMap } from 'node:module';\n// module.cjs\n// In a CommonJS module\nconst { findSourceMap, SourceMap } = require('node:module');\nThis method returns whether the Source Map v3 support for stack\ntraces is enabled.
\n\n" }, { "textRaw": "`module.findSourceMap(path)`", "type": "method", "name": "findSourceMap", "meta": { "added": [ "v13.7.0", "v12.17.0" ], "changes": [] }, "signatures": [ { "return": { "textRaw": "Returns: {module.SourceMap|undefined} Returns `module.SourceMap` if a source map is found, `undefined` otherwise.", "name": "return", "type": "module.SourceMap|undefined", "desc": "Returns `module.SourceMap` if a source map is found, `undefined` otherwise." }, "params": [ { "textRaw": "`path` {string}", "name": "path", "type": "string" } ] } ], "desc": "path is the resolved path for the file for which a corresponding source map\nshould be fetched.
This function enables or disables the Source Map v3 support for\nstack traces.
\nIt provides same features as launching Node.js process with commandline options\n--enable-source-maps, with additional options to alter the support for files\nin node_modules or generated codes.
Only source maps in JavaScript files that are loaded after source maps has been\nenabled will be parsed and loaded. Preferably, use the commandline options\n--enable-source-maps to avoid losing track of source maps of modules loaded\nbefore this API call.
Getter for the payload used to construct the SourceMap instance.
Given a line offset and column offset in the generated source\nfile, returns an object representing the SourceMap range in the\noriginal file if found, or an empty object if not.
\nThe object returned contains the following keys:
\nThe returned value represents the raw range as it appears in the\nSourceMap, based on zero-indexed offsets, not 1-indexed line and\ncolumn numbers as they appear in Error messages and CallSite\nobjects.
\nTo get the corresponding 1-indexed line and column numbers from a\nlineNumber and columnNumber as they are reported by Error stacks\nand CallSite objects, use sourceMap.findOrigin(lineNumber, columnNumber)
Given a 1-indexed lineNumber and columnNumber from a call site in\nthe generated source, find the corresponding call site location\nin the original source.
If the lineNumber and columnNumber provided are not found in any\nsource map, then an empty object is returned. Otherwise, the\nreturned object contains the following keys:
Creates a new sourceMap instance.
payload is an object with keys matching the Source map v3 format:
file: <string>version: <number>sources: <string[]>sourcesContent: <string[]>names: <string[]>mappings: <string>sourceRoot: <string>lineLengths is an optional array of the length of each line in the\ngenerated code.
", "miscs": [ { "textRaw": "Enabling", "name": "enabling", "desc": "
Module resolution and loading can be customized by registering a file which\nexports a set of hooks. This can be done using the register method\nfrom node:module, which you can run before your application code by\nusing the --import flag:
node --import ./register-hooks.js ./my-app.js\n// register-hooks.js\nimport { register } from 'node:module';\n\nregister('./hooks.mjs', import.meta.url);\n// register-hooks.js\nconst { register } = require('node:module');\nconst { pathToFileURL } = require('node:url');\n\nregister('./hooks.mjs', pathToFileURL(__filename));\nThe file passed to --import can also be an export from a dependency:
node --import some-package/register ./my-app.js\nWhere some-package has an \"exports\" field defining the /register\nexport to map to a file that calls register(), like the following register-hooks.js\nexample.
Using --import ensures that the hooks are registered before any application\nfiles are imported, including the entry point of the application. Alternatively,\nregister can be called from the entry point, but dynamic import() must be\nused for any code that should be run after the hooks are registered:
import { register } from 'node:module';\n\nregister('http-to-https', import.meta.url);\n\n// Because this is a dynamic `import()`, the `http-to-https` hooks will run\n// to handle `./my-app.js` and any other files it imports or requires.\nawait import('./my-app.js');\nconst { register } = require('node:module');\nconst { pathToFileURL } = require('node:url');\n\nregister('http-to-https', pathToFileURL(__filename));\n\n// Because this is a dynamic `import()`, the `http-to-https` hooks will run\n// to handle `./my-app.js` and any other files it imports or requires.\nimport('./my-app.js');\nIn this example, we are registering the http-to-https hooks, but they will\nonly be available for subsequently imported modules—in this case, my-app.js\nand anything it references via import (and optionally require). If the\nimport('./my-app.js') had instead been a static import './my-app.js', the\napp would have already been loaded before the http-to-https hooks were\nregistered. This due to the ES modules specification, where static imports are\nevaluated from the leaves of the tree first, then back to the trunk. There can\nbe static imports within my-app.js, which will not be evaluated until\nmy-app.js is dynamically imported.
my-app.js can also be CommonJS. Customization hooks will run for any\nmodules that it references via import (and optionally require).
Finally, if all you want to do is register hooks before your app runs and you\ndon't want to create a separate file for that purpose, you can pass a data:\nURL to --import:
node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"http-to-https\", pathToFileURL(\"./\"));' ./my-app.js\nIt's possible to call register more than once:
// entrypoint.mjs\nimport { register } from 'node:module';\n\nregister('./foo.mjs', import.meta.url);\nregister('./bar.mjs', import.meta.url);\nawait import('./my-app.mjs');\n// entrypoint.cjs\nconst { register } = require('node:module');\nconst { pathToFileURL } = require('node:url');\n\nconst parentURL = pathToFileURL(__filename);\nregister('./foo.mjs', parentURL);\nregister('./bar.mjs', parentURL);\nimport('./my-app.mjs');\nIn this example, the registered hooks will form chains. These chains run\nlast-in, first out (LIFO). If both foo.mjs and bar.mjs define a resolve\nhook, they will be called like so (note the right-to-left):\nnode's default ← ./foo.mjs ← ./bar.mjs\n(starting with ./bar.mjs, then ./foo.mjs, then the Node.js default).\nThe same applies to all the other hooks.
The registered hooks also affect register itself. In this example,\nbar.mjs will be resolved and loaded via the hooks registered by foo.mjs\n(because foo's hooks will have already been added to the chain). This allows\nfor things like writing hooks in non-JavaScript languages, so long as\nearlier registered hooks transpile into JavaScript.
The register method cannot be called from within the module that defines the\nhooks.
Module customization hooks run on a dedicated thread, separate from the main\nthread that runs application code. This means mutating global variables won't\naffect the other thread(s), and message channels must be used to communicate\nbetween the threads.
\nThe register method can be used to pass data to an initialize hook. The\ndata passed to the hook may include transferable objects like ports.
import { register } from 'node:module';\nimport { MessageChannel } from 'node:worker_threads';\n\n// This example demonstrates how a message channel can be used to\n// communicate with the hooks, by sending `port2` to the hooks.\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (msg) => {\n console.log(msg);\n});\nport1.unref();\n\nregister('./my-hooks.mjs', {\n parentURL: import.meta.url,\n data: { number: 1, port: port2 },\n transferList: [port2],\n});\nconst { register } = require('node:module');\nconst { pathToFileURL } = require('node:url');\nconst { MessageChannel } = require('node:worker_threads');\n\n// This example showcases how a message channel can be used to\n// communicate with the hooks, by sending `port2` to the hooks.\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (msg) => {\n console.log(msg);\n});\nport1.unref();\n\nregister('./my-hooks.mjs', {\n parentURL: pathToFileURL(__filename),\n data: { number: 1, port: port2 },\n transferList: [port2],\n});\nThe register method can be used to register a module that exports a set of\nhooks. The hooks are functions that are called by Node.js to customize the\nmodule resolution and loading process. The exported functions must have specific\nnames and signatures, and they must be exported as named exports.
export async function initialize({ number, port }) {\n // Receives data from `register`.\n}\n\nexport async function resolve(specifier, context, nextResolve) {\n // Take an `import` or `require` specifier and resolve it to a URL.\n}\n\nexport async function load(url, context, nextLoad) {\n // Take a resolved URL and return the source code to be evaluated.\n}\nHooks are part of a chain, even if that chain consists of only one\ncustom (user-provided) hook and the default hook, which is always present. Hook\nfunctions nest: each one must always return a plain object, and chaining happens\nas a result of each function calling next<hookName>(), which is a reference to\nthe subsequent loader's hook (in LIFO order).
A hook that returns a value lacking a required property triggers an exception. A\nhook that returns without calling next<hookName>() and without returning\nshortCircuit: true also triggers an exception. These errors are to help\nprevent unintentional breaks in the chain. Return shortCircuit: true from a\nhook to signal that the chain is intentionally ending at your hook.
Hooks are run in a separate thread, isolated from the main thread where\napplication code runs. That means it is a different realm. The hooks thread\nmay be terminated by the main thread at any time, so do not depend on\nasynchronous operations (like console.log) to complete.
The initialize hook provides a way to define a custom function that runs in\nthe hooks thread when the hooks module is initialized. Initialization happens\nwhen the hooks module is registered via register.
This hook can receive data from a register invocation, including\nports and other transferable objects. The return value of initialize can be a\n<Promise>, in which case it will be awaited before the main application thread\nexecution resumes.
Module customization code:
\n// path-to-my-hooks.js\n\nexport async function initialize({ number, port }) {\n port.postMessage(`increment: ${number + 1}`);\n}\nCaller code:
\nimport assert from 'node:assert';\nimport { register } from 'node:module';\nimport { MessageChannel } from 'node:worker_threads';\n\n// This example showcases how a message channel can be used to communicate\n// between the main (application) thread and the hooks running on the hooks\n// thread, by sending `port2` to the `initialize` hook.\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (msg) => {\n assert.strictEqual(msg, 'increment: 2');\n});\nport1.unref();\n\nregister('./path-to-my-hooks.js', {\n parentURL: import.meta.url,\n data: { number: 1, port: port2 },\n transferList: [port2],\n});\nconst assert = require('node:assert');\nconst { register } = require('node:module');\nconst { pathToFileURL } = require('node:url');\nconst { MessageChannel } = require('node:worker_threads');\n\n// This example showcases how a message channel can be used to communicate\n// between the main (application) thread and the hooks running on the hooks\n// thread, by sending `port2` to the `initialize` hook.\nconst { port1, port2 } = new MessageChannel();\n\nport1.on('message', (msg) => {\n assert.strictEqual(msg, 'increment: 2');\n});\nport1.unref();\n\nregister('./path-to-my-hooks.js', {\n parentURL: pathToFileURL(__filename),\n data: { number: 1, port: port2 },\n transferList: [port2],\n});\n\n\nWarning Despite support for returning promises and async functions, calls\nto
\nresolvemay block the main thread which can impact performance.
The resolve hook chain is responsible for telling Node.js where to find and\nhow to cache a given import statement or expression, or require call. It can\noptionally return a format (such as 'module') as a hint to the load hook. If\na format is specified, the load hook is ultimately responsible for providing\nthe final format value (and it is free to ignore the hint provided by\nresolve); if resolve provides a format, a custom load hook is required\neven if only to pass the value to the Node.js default load hook.
Import type attributes are part of the cache key for saving loaded modules into\nthe internal module cache. The resolve hook is responsible for returning an\nimportAttributes object if the module should be cached with different\nattributes than were present in the source code.
The conditions property in context is an array of conditions for\npackage exports conditions that apply to this resolution\nrequest. They can be used for looking up conditional mappings elsewhere or to\nmodify the list when calling the default resolution logic.
The current package exports conditions are always in\nthe context.conditions array passed into the hook. To guarantee default\nNode.js module specifier resolution behavior when calling defaultResolve, the\ncontext.conditions array passed to it must include all elements of the\ncontext.conditions array originally passed into the resolve hook.
export async function resolve(specifier, context, nextResolve) {\n const { parentURL = null } = context;\n\n if (Math.random() > 0.5) { // Some condition.\n // For some or all specifiers, do some custom logic for resolving.\n // Always return an object of the form {url: <string>}.\n return {\n shortCircuit: true,\n url: parentURL ?\n new URL(specifier, parentURL).href :\n new URL(specifier).href,\n };\n }\n\n if (Math.random() < 0.5) { // Another condition.\n // When calling `defaultResolve`, the arguments can be modified. In this\n // case it's adding another value for matching conditional exports.\n return nextResolve(specifier, {\n ...context,\n conditions: [...context.conditions, 'another-condition'],\n });\n }\n\n // Defer to the next hook in the chain, which would be the\n // Node.js default resolve if this is the last user-specified loader.\n return nextResolve(specifier);\n}\nThe load hook provides a way to define a custom method of determining how a\nURL should be interpreted, retrieved, and parsed. It is also in charge of\nvalidating the import attributes.
The final value of format must be one of the following:
format | \nDescription | \nAcceptable types for source returned by load | \n
|---|---|---|
'builtin' | \nLoad a Node.js builtin module | \n<null> | \n
'commonjs' | \nLoad a Node.js CommonJS module | \n<string> | <ArrayBuffer> | <TypedArray> | <null> | <undefined> | \n
'json' | \nLoad a JSON file | \n<string> | <ArrayBuffer> | <TypedArray> | \n
'module' | \nLoad an ES module | \n<string> | <ArrayBuffer> | <TypedArray> | \n
'wasm' | \nLoad a WebAssembly module | \n<ArrayBuffer> | <TypedArray> | \n
The value of source is ignored for type 'builtin' because currently it is\nnot possible to replace the value of a Node.js builtin (core) module.
Omitting vs providing a source for 'commonjs' has very different effects:
source is provided, all require calls from this module will be\nprocessed by the ESM loader with registered resolve and load hooks; all\nrequire.resolve calls from this module will be processed by the ESM loader\nwith registered resolve hooks; only a subset of the CommonJS API will be\navailable (e.g. no require.extensions, no require.cache, no\nrequire.resolve.paths) and monkey-patching on the CommonJS module loader\nwill not apply.source is undefined or null, it will be handled by the CommonJS module\nloader and require/require.resolve calls will not go through the\nregistered hooks. This behavior for nullish source is temporary — in the\nfuture, nullish source will not be supported.When node is run with --experimental-default-type=commonjs, the Node.js\ninternal load implementation, which is the value of next for the\nlast hook in the load chain, returns null for source when format is\n'commonjs' for backward compatibility. Here is an example hook that would\nopt-in to using the non-default behavior:
import { readFile } from 'node:fs/promises';\n\nexport async function load(url, context, nextLoad) {\n const result = await nextLoad(url, context);\n if (result.format === 'commonjs') {\n result.source ??= await readFile(new URL(result.responseURL ?? url));\n }\n return result;\n}\n\n\nWarning: The ESM
\nloadhook and namespaced exports from CommonJS modules\nare incompatible. Attempting to use them together will result in an empty\nobject from the import. This may be addressed in the future.
\n\nThese types all correspond to classes defined in ECMAScript.
\n
If the source value of a text-based format (i.e., 'json', 'module')\nis not a string, it is converted to a string using util.TextDecoder.
The load hook provides a way to define a custom method for retrieving the\nsource code of a resolved URL. This would allow a loader to potentially avoid\nreading files from disk. It could also be used to map an unrecognized format to\na supported one, for example yaml to module.
export async function load(url, context, nextLoad) {\n const { format } = context;\n\n if (Math.random() > 0.5) { // Some condition\n /*\n For some or all URLs, do some custom logic for retrieving the source.\n Always return an object of the form {\n format: <string>,\n source: <string|buffer>,\n }.\n */\n return {\n format,\n shortCircuit: true,\n source: '...',\n };\n }\n\n // Defer to the next hook in the chain.\n return nextLoad(url);\n}\nIn a more advanced scenario, this can also be used to transform an unsupported\nsource to a supported one (see Examples below).
\nThe various module customization hooks can be used together to accomplish\nwide-ranging customizations of the Node.js code loading and evaluation\nbehaviors.
" } ], "modules": [ { "textRaw": "Import from HTTPS", "name": "import_from_https", "desc": "The hook below registers hooks to enable rudimentary support for such\nspecifiers. While this may seem like a significant improvement to Node.js core\nfunctionality, there are substantial downsides to actually using these hooks:\nperformance is much slower than loading files from disk, there is no caching,\nand there is no security.
\n// https-hooks.mjs\nimport { get } from 'node:https';\n\nexport function load(url, context, nextLoad) {\n // For JavaScript to be loaded over the network, we need to fetch and\n // return it.\n if (url.startsWith('https://')) {\n return new Promise((resolve, reject) => {\n get(url, (res) => {\n let data = '';\n res.setEncoding('utf8');\n res.on('data', (chunk) => data += chunk);\n res.on('end', () => resolve({\n // This example assumes all network-provided JavaScript is ES module\n // code.\n format: 'module',\n shortCircuit: true,\n source: data,\n }));\n }).on('error', (err) => reject(err));\n });\n }\n\n // Let Node.js handle all other URLs.\n return nextLoad(url);\n}\n// main.mjs\nimport { VERSION } from 'https://coffeescript.org/browser-compiler-modern/coffeescript.js';\n\nconsole.log(VERSION);\nWith the preceding hooks module, running\nnode --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(pathToFileURL(\"./https-hooks.mjs\"));' ./main.mjs\nprints the current version of CoffeeScript per the module at the URL in\nmain.mjs.
Sources that are in formats Node.js doesn't understand can be converted into\nJavaScript using the load hook.
This is less performant than transpiling source files before running Node.js;\ntranspiler hooks should only be used for development and testing purposes.
\n// coffeescript-hooks.mjs\nimport { readFile } from 'node:fs/promises';\nimport { dirname, extname, resolve as resolvePath } from 'node:path';\nimport { cwd } from 'node:process';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport coffeescript from 'coffeescript';\n\nconst extensionsRegex = /\\.(coffee|litcoffee|coffee\\.md)$/;\n\nexport async function load(url, context, nextLoad) {\n if (extensionsRegex.test(url)) {\n // CoffeeScript files can be either CommonJS or ES modules, so we want any\n // CoffeeScript file to be treated by Node.js the same as a .js file at the\n // same location. To determine how Node.js would interpret an arbitrary .js\n // file, search up the file system for the nearest parent package.json file\n // and read its \"type\" field.\n const format = await getPackageType(url);\n\n const { source: rawSource } = await nextLoad(url, { ...context, format });\n // This hook converts CoffeeScript source code into JavaScript source code\n // for all imported CoffeeScript files.\n const transformedSource = coffeescript.compile(rawSource.toString(), url);\n\n return {\n format,\n shortCircuit: true,\n source: transformedSource,\n };\n }\n\n // Let Node.js handle all other URLs.\n return nextLoad(url);\n}\n\nasync function getPackageType(url) {\n // `url` is only a file path during the first iteration when passed the\n // resolved url from the load() hook\n // an actual file path from load() will contain a file extension as it's\n // required by the spec\n // this simple truthy check for whether `url` contains a file extension will\n // work for most projects but does not cover some edge-cases (such as\n // extensionless files or a url ending in a trailing space)\n const isFilePath = !!extname(url);\n // If it is a file path, get the directory it's in\n const dir = isFilePath ?\n dirname(fileURLToPath(url)) :\n url;\n // Compose a file path to a package.json in the same directory,\n // which may or may not exist\n const packagePath = resolvePath(dir, 'package.json');\n // Try to read the possibly nonexistent package.json\n const type = await readFile(packagePath, { encoding: 'utf8' })\n .then((filestring) => JSON.parse(filestring).type)\n .catch((err) => {\n if (err?.code !== 'ENOENT') console.error(err);\n });\n // If package.json existed and contained a `type` field with a value, voilà\n if (type) return type;\n // Otherwise, (if not at the root) continue checking the next directory up\n // If at the root, stop and return false\n return dir.length > 1 && getPackageType(resolvePath(dir, '..'));\n}\n# main.coffee\nimport { scream } from './scream.coffee'\nconsole.log scream 'hello, world'\n\nimport { version } from 'node:process'\nconsole.log \"Brought to you by Node.js version #{version}\"\n# scream.coffee\nexport scream = (str) -> str.toUpperCase()\nWith the preceding hooks module, running\nnode --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(pathToFileURL(\"./coffeescript-hooks.mjs\"));' ./main.coffee\ncauses main.coffee to be turned into JavaScript after its source code is\nloaded from disk but before Node.js executes it; and so on for any .coffee,\n.litcoffee or .coffee.md files referenced via import statements of any\nloaded file.
The previous two examples defined load hooks. This is an example of a\nresolve hook. This hooks module reads an import-map.json file that defines\nwhich specifiers to override to other URLs (this is a very simplistic\nimplementation of a small subset of the \"import maps\" specification).
// import-map-hooks.js\nimport fs from 'node:fs/promises';\n\nconst { imports } = JSON.parse(await fs.readFile('import-map.json'));\n\nexport async function resolve(specifier, context, nextResolve) {\n if (Object.hasOwn(imports, specifier)) {\n return nextResolve(imports[specifier], context);\n }\n\n return nextResolve(specifier, context);\n}\nWith these files:
\n// main.js\nimport 'a-module';\n// import-map.json\n{\n \"imports\": {\n \"a-module\": \"./some-module.js\"\n }\n}\n// some-module.js\nconsole.log('some module!');\nRunning node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(pathToFileURL(\"./import-map-hooks.js\"));' main.js\nshould print some module!.