module.builtinModules#

• <string[]>

A list of the names of all modules provided by Node.js. Can be used to verifyif a module is maintained by a third party or not.

module in this context isn't the same object that's providedby themodule wrapper. To access it, require theModule module:

// module.mjs// In an ECMAScript moduleimport { builtinModulesas builtin }from'node:module';// module.cjs// In a CommonJS moduleconst builtin =require('node:module').builtinModules;copy

module.createRequire(filename)#

• filename<string> |<URL> Filename to be used to construct the requirefunction. Must be a file URL object, file URL string, or absolute pathstring.
• Returns:<require> Require function

import { createRequire }from'node:module';constrequire =createRequire(import.meta.url);// sibling-module.js is a CommonJS module.const siblingModule =require('./sibling-module');copy

module.findPackageJSON(specifier[, base])#

• specifier<string> |<URL> The specifier for the module whosepackage.json toretrieve. When passing abare specifier, thepackage.json at the root ofthe package is returned. When passing arelative specifier or anabsolute specifier,the closest parentpackage.json is returned.
• base<string> |<URL> The absolute location (file: URL string or FS path) of thecontaining module. For CJS, use__filename (not__dirname!); for ESM, useimport.meta.url. You do not need to pass it ifspecifier is anabsolute specifier.
• Returns:<string> |<undefined> A path if thepackage.json is found. Whenspecifieris a package, the package's rootpackage.json; when a relative or unresolved, the closestpackage.json to thespecifier.

Caveat: Do not use this to try to determine module format. There are many things affectingthat determination; thetype field of package.json is theleast definitive (ex file extensionsupersedes it, and a loader hook supersedes that).

Caveat: This currently leverages only the built-in default resolver; ifresolve customization hooks are registered, they will not affect the resolution.This may change in the future.

/path/to/project  ├ packages/    ├ bar/      ├ bar.js      └ package.json // name = '@foo/bar'    └ qux/      ├ node_modules/        └ some-package/          └ package.json // name = 'some-package'      ├ qux.js      └ package.json // name = '@foo/qux'  ├ main.js  └ package.json // name = '@foo'copy

// /path/to/project/packages/bar/bar.jsimport { findPackageJSON }from'node:module';findPackageJSON('..',import.meta.url);// '/path/to/project/package.json'// Same result when passing an absolute specifier instead:findPackageJSON(newURL('../',import.meta.url));findPackageJSON(import.meta.resolve('../'));findPackageJSON('some-package',import.meta.url);// '/path/to/project/packages/bar/node_modules/some-package/package.json'// When passing an absolute specifier, you might get a different result if the// resolved module is inside a subfolder that has nested `package.json`.findPackageJSON(import.meta.resolve('some-package'));// '/path/to/project/packages/bar/node_modules/some-package/some-subfolder/package.json'findPackageJSON('@foo/qux',import.meta.url);// '/path/to/project/packages/qux/package.json'// /path/to/project/packages/bar/bar.jsconst { findPackageJSON } =require('node:module');const { pathToFileURL } =require('node:url');const path =require('node:path');findPackageJSON('..', __filename);// '/path/to/project/package.json'// Same result when passing an absolute specifier instead:findPackageJSON(pathToFileURL(path.join(__dirname,'..')));findPackageJSON('some-package', __filename);// '/path/to/project/packages/bar/node_modules/some-package/package.json'// When passing an absolute specifier, you might get a different result if the// resolved module is inside a subfolder that has nested `package.json`.findPackageJSON(pathToFileURL(require.resolve('some-package')));// '/path/to/project/packages/bar/node_modules/some-package/some-subfolder/package.json'findPackageJSON('@foo/qux', __filename);// '/path/to/project/packages/qux/package.json'copy

module.isBuiltin(moduleName)#

• moduleName<string> name of the module
• Returns:<boolean> returns true if the module is builtin else returns false

import { isBuiltin }from'node:module';isBuiltin('node:fs');// trueisBuiltin('fs');// trueisBuiltin('wss');// falsecopy

module.register(specifier[, parentURL][, options])#

• specifier<string> |<URL> Customization hooks to be registered; this should bethe same string that would be passed toimport(), except that if it isrelative, it is resolved relative toparentURL.
• parentURL<string> |<URL> If you want to resolvespecifier relative to a baseURL, such asimport.meta.url, you can pass that URL here.Default:'data:'
• options<Object>
  • parentURL<string> |<URL> If you want to resolvespecifier relative to abase URL, such asimport.meta.url, you can pass that URL here. Thisproperty is ignored if theparentURL is supplied as the second argument.Default:'data:'
  • data<any> Any arbitrary, cloneable JavaScript value to pass into theinitialize hook.
  • transferList<Object[]>transferable objects to be passed into theinitialize hook.

Register a module that exportshooks that customize Node.js moduleresolution and loading behavior. SeeCustomization hooks.

This feature requires--allow-worker if used with thePermission Model.

module.registerHooks(options)#

• options<Object>
  • load<Function> |<undefined> Seeload hook.Default:undefined.
  • resolve<Function> |<undefined> Seeresolve hook.Default:undefined.

Registerhooks that customize Node.js module resolution and loading behavior.SeeCustomization hooks.

module.stripTypeScriptTypes(code[, options])#

• code<string> The code to strip type annotations from.
• options<Object>
  • mode<string>Default:'strip'. Possible values are:
    • 'strip' Only strip type annotations without performing the transformation of TypeScript features.
    • 'transform' Strip type annotations and transform TypeScript features to JavaScript.
  • sourceMap<boolean>Default:false. Only whenmode is'transform', iftrue, a source mapwill be generated for the transformed code.
  • sourceUrl<string> Specifies the source url used in the source map.
• Returns:<string> The code with type annotations stripped.module.stripTypeScriptTypes() removes type annotations from TypeScript code. Itcan be used to strip type annotations from TypeScript code before running itwithvm.runInContext() orvm.compileFunction().By default, it will throw an error if the code contains TypeScript featuresthat require transformation such asEnums,seetype-stripping for more information.When mode is'transform', it also transforms TypeScript features to JavaScript,seetransform TypeScript features for more information.When mode is'strip', source maps are not generated, because locations are preserved.IfsourceMap is provided, when mode is'strip', an error will be thrown.

WARNING: The output of this function should not be considered stable across Node.js versions,due to changes in the TypeScript parser.

import { stripTypeScriptTypes }from'node:module';const code ='const a: number = 1;';const strippedCode =stripTypeScriptTypes(code);console.log(strippedCode);// Prints: const a         = 1;const { stripTypeScriptTypes } =require('node:module');const code ='const a: number = 1;';const strippedCode =stripTypeScriptTypes(code);console.log(strippedCode);// Prints: const a         = 1;copy

IfsourceUrl is provided, it will be used appended as a comment at the end of the output:

import { stripTypeScriptTypes }from'node:module';const code ='const a: number = 1;';const strippedCode =stripTypeScriptTypes(code, {mode:'strip',sourceUrl:'source.ts' });console.log(strippedCode);// Prints: const a         = 1\n\n//# sourceURL=source.ts;const { stripTypeScriptTypes } =require('node:module');const code ='const a: number = 1;';const strippedCode =stripTypeScriptTypes(code, {mode:'strip',sourceUrl:'source.ts' });console.log(strippedCode);// Prints: const a         = 1\n\n//# sourceURL=source.ts;copy

Whenmode is'transform', the code is transformed to #"checkbox" checked aria-label="Show modern ES modules syntax">import { stripTypeScriptTypes }from'node:module';const code =` namespace MathUtil { export const add = (a: number, b: number) => a + b; }`;const strippedCode =stripTypeScriptTypes(code, {mode:'transform',sourceMap:true });console.log(strippedCode);// Prints:// var MathUtil;// (function(MathUtil) {// MathUtil.add = (a, b)=>a + b;// })(MathUtil || (MathUtil = {}));// # sourceMappingURL=data:application/json;base64, ...const { stripTypeScriptTypes } =require('node:module');const code =` namespace MathUtil { export const add = (a: number, b: number) => a + b; }`;const strippedCode =stripTypeScriptTypes(code, {mode:'transform',sourceMap:true });console.log(strippedCode);// Prints:// var MathUtil;// (function(MathUtil) {// MathUtil.add = (a, b)=>a + b;// })(MathUtil || (MathUtil = {}));// # sourceMappingURL=data:application/json;base64, ...copy

module.syncBuiltinESMExports()#

Themodule.syncBuiltinESMExports() method updates all the live bindings forbuiltinES Modules to match the properties of theCommonJS exports. Itdoes not add or remove exported names from theES Modules.

const fs =require('node:fs');const assert =require('node:assert');const { syncBuiltinESMExports } =require('node:module');fs.readFile = newAPI;delete fs.readFileSync;functionnewAPI() {// ...}fs.newAPI = newAPI;syncBuiltinESMExports();import('node:fs').then((esmFS) => {// It syncs the existing readFile property with the new value  assert.strictEqual(esmFS.readFile, newAPI);// readFileSync has been deleted from the required fs  assert.strictEqual('readFileSync'in fs,false);// syncBuiltinESMExports() does not remove readFileSync from esmFS  assert.strictEqual('readFileSync'in esmFS,true);// syncBuiltinESMExports() does not add names  assert.strictEqual(esmFS.newAPI,undefined);});copy

module.constants.compileCacheStatus#

The following constants are returned as thestatus field in the object returned bymodule.enableCompileCache() to indicate the result of the attempt to enable themodule compile cache.

module.enableCompileCache([cacheDir])#

• cacheDir<string> |<undefined> Optional path to specify the directory where the compile cachewill be stored/retrieved.
• Returns:<Object>
  • status<integer> One of themodule.constants.compileCacheStatus
  • message<string> |<undefined> If Node.js cannot enable the compile cache, this containsthe error message. Only set ifstatus ismodule.constants.compileCacheStatus.FAILED.
  • directory<string> |<undefined> If the compile cache is enabled, this contains the directorywhere the compile cache is stored. Only set ifstatus ismodule.constants.compileCacheStatus.ENABLED ormodule.constants.compileCacheStatus.ALREADY_ENABLED.

Enablemodule compile cache in the current Node.js instance.

IfcacheDir is not specified, Node.js will either use the directory specified by theNODE_COMPILE_CACHE=dir environment variable if it's set, or usepath.join(os.tmpdir(), 'node-compile-cache') otherwise. For general use cases, it'srecommended to callmodule.enableCompileCache() without specifying thecacheDir,so that the directory can be overridden by theNODE_COMPILE_CACHE environmentvariable when necessary.

Since compile cache is supposed to be a quiet optimization that is not required for theapplication to be functional, this method is designed to not throw any exception when thecompile cache cannot be enabled. Instead, it will return an object containing an errormessage in themessage field to aid debugging.If compile cache is enabled successfully, thedirectory field in the returned objectcontains the path to the directory where the compile cache is stored. Thestatusfield in the returned object would be one of themodule.constants.compileCacheStatusvalues to indicate the result of the attempt to enable themodule compile cache.

This method only affects the current Node.js instance. To enable it in child worker threads,either call this method in child worker threads too, or set theprocess.env.NODE_COMPILE_CACHE value to compile cache directory so the behavior canbe inherited into the child workers. The directory can be obtained either from thedirectory field returned by this method, or withmodule.getCompileCacheDir().

module.flushCompileCache()#

Flush themodule compile cache accumulated from modules already loadedin the current Node.js instance to disk. This returns after all the flushingfile system operations come to an end, no matter they succeed or not. If thereare any errors, this will fail silently, since compile cache misses should notinterfere with the actual operation of the application.

module.getCompileCacheDir()#

• Returns:<string> |<undefined> Path to themodule compile cache directory if it is enabled,orundefined otherwise.

Enabling#

Module resolution and loading can be customized by:

1. Registering a file which exports a set of asynchronous hook functions, using theregister method fromnode:module,
2. Registering a set of synchronous hook functions using theregisterHooks methodfromnode:module.

The hooks can be registered before the application code is run by using the--import or--require flag:

node --import ./register-hooks.js ./my-app.jsnode --require ./register-hooks.js ./my-app.jscopy

// register-hooks.js// This file can only be require()-ed if it doesn't contain top-level await.// Use module.register() to register asynchronous hooks in a dedicated thread.import { register }from'node:module';register('./hooks.mjs',import.meta.url);// register-hooks.jsconst { register } =require('node:module');const { pathToFileURL } =require('node:url');// Use module.register() to register asynchronous hooks in a dedicated thread.register('./hooks.mjs',pathToFileURL(__filename));copy

// Use module.registerHooks() to register synchronous hooks in the main thread.import { registerHooks }from'node:module';registerHooks({resolve(specifier, context, nextResolve) {/* implementation */ },load(url, context, nextLoad) {/* implementation */ },});// Use module.registerHooks() to register synchronous hooks in the main thread.const { registerHooks } =require('node:module');registerHooks({resolve(specifier, context, nextResolve) {/* implementation */ },load(url, context, nextLoad) {/* implementation */ },});copy

The file passed to--import or--require can also be an export from a dependency:

node --import some-package/register ./my-app.jsnode --require some-package/register ./my-app.jscopy

Wheresome-package has an"exports" field defining the/registerexport to map to a file that callsregister(), like the followingregister-hooks.jsexample.

Using--import or--require ensures that the hooks are registered before anyapplication files are imported, including the entry point of the application and forany worker threads by default as well.

Alternatively,register() andregisterHooks() can be called from the entry point,though dynamicimport() must be used for any ESM code that should be run after the hooksare registered.

import { register }from'node:module';register('http-to-https',import.meta.url);// Because this is a dynamic `import()`, the `http-to-https` hooks will run// to handle `./my-app.js` and any other files it imports or requires.awaitimport('./my-app.js');const { register } =require('node:module');const { pathToFileURL } =require('node:url');register('http-to-https',pathToFileURL(__filename));// Because this is a dynamic `import()`, the `http-to-https` hooks will run// to handle `./my-app.js` and any other files it imports or requires.import('./my-app.js');copy

Customization hooks will run for any modules loaded later than the registrationand the modules they reference viaimport and the built-inrequire.require function created by users usingmodule.createRequire() can only becustomized by the synchronous hooks.

In this example, we are registering thehttp-to-https hooks, but they willonly be available for subsequently imported modules — in this case,my-app.jsand anything it references viaimport or built-inrequire in CommonJS dependencies.

If theimport('./my-app.js') had instead been a staticimport './my-app.js', theapp would havealready been loadedbefore thehttp-to-https hooks wereregistered. This due to the ES modules specification, where static imports areevaluated from the leaves of the tree first, then back to the trunk. There canbe static importswithinmy-app.js, which will not be evaluated untilmy-app.js is dynamically imported.

If synchronous hooks are used, bothimport,require and userrequire createdusingcreateRequire() are supported.

import { registerHooks, createRequire }from'node:module';registerHooks({/* implementation of synchronous hooks */ });constrequire =createRequire(import.meta.url);// The synchronous hooks affect import, require() and user require() function// created through createRequire().awaitimport('./my-app.js');require('./my-app-2.js');const { register, registerHooks } =require('node:module');const { pathToFileURL } =require('node:url');registerHooks({/* implementation of synchronous hooks */ });const userRequire =createRequire(__filename);// The synchronous hooks affect import, require() and user require() function// created through createRequire().import('./my-app.js');require('./my-app-2.js');userRequire('./my-app-3.js');copy

Finally, if all you want to do is register hooks before your app runs and youdon't want to create a separate file for that purpose, you can pass adata:URL to--import:

node --import'data:text/javascript,import { register } from "node:module"; import { pathToFileURL } from "node:url"; register("http-to-https", pathToFileURL("./"));' ./my-app.jscopy

Chaining#

It's possible to callregister more than once:

// entrypoint.mjsimport { register }from'node:module';register('./foo.mjs',import.meta.url);register('./bar.mjs',import.meta.url);awaitimport('./my-app.mjs');// entrypoint.cjsconst { register } =require('node:module');const { pathToFileURL } =require('node:url');const parentURL =pathToFileURL(__filename);register('./foo.mjs', parentURL);register('./bar.mjs', parentURL);import('./my-app.mjs');copy

In this example, the registered hooks will form chains. These chains runlast-in, first out (LIFO). If bothfoo.mjs andbar.mjs define aresolvehook, they will be called like so (note the right-to-left):node's default ←./foo.mjs ←./bar.mjs(starting with./bar.mjs, then./foo.mjs, then the Node.js default).The same applies to all the other hooks.

The registered hooks also affectregister itself. In this example,bar.mjs will be resolved and loaded via the hooks registered byfoo.mjs(becausefoo's hooks will have already been added to the chain). This allowsfor things like writing hooks in non-JavaScript languages, so long asearlier registered hooks transpile into JavaScript.

Theregister method cannot be called from within the module that defines thehooks.

Chaining ofregisterHooks work similarly. If synchronous and asynchronoushooks are mixed, the synchronous hooks are always run first before the asynchronoushooks start running, that is, in the last synchronous hook being run, its nexthook includes invocation of the asynchronous hooks.

// entrypoint.mjsimport { registerHooks }from'node:module';const hook1 = {/* implementation of hooks */ };const hook2 = {/* implementation of hooks */ };// hook2 run before hook1.registerHooks(hook1);registerHooks(hook2);// entrypoint.cjsconst { registerHooks } =require('node:module');const hook1 = {/* implementation of hooks */ };const hook2 = {/* implementation of hooks */ };// hook2 run before hook1.registerHooks(hook1);registerHooks(hook2);copy

Communication with module customization hooks#

Asynchronous hooks run on a dedicated thread, separate from the mainthread that runs application code. This means mutating global variables won'taffect the other thread(s), and message channels must be used to communicatebetween the threads.

Theregister method can be used to pass data to aninitialize hook. Thedata passed to the hook may include transferable objects like ports.

import { register }from'node:module';import {MessageChannel }from'node:worker_threads';// This example demonstrates how a message channel can be used to// communicate with the hooks, by sending `port2` to the hooks.const { port1, port2 } =newMessageChannel();port1.on('message',(msg) => {console.log(msg);});port1.unref();register('./my-hooks.mjs', {parentURL:import.meta.url,data: {number:1,port: port2 },transferList: [port2],});const { register } =require('node:module');const { pathToFileURL } =require('node:url');const {MessageChannel } =require('node:worker_threads');// This example showcases how a message channel can be used to// communicate with the hooks, by sending `port2` to the hooks.const { port1, port2 } =newMessageChannel();port1.on('message',(msg) => {console.log(msg);});port1.unref();register('./my-hooks.mjs', {parentURL:pathToFileURL(__filename),data: {number:1,port: port2 },transferList: [port2],});copy

Synchronous module hooks are run on the same thread where the application code isrun. They can directly mutate the globals of the context accessed by the main thread.

Hooks#

exportasyncfunctioninitialize({ number, port }) {// Receives data from `register`.}exportasyncfunctionresolve(specifier, context, nextResolve) {// Take an `import` or `require` specifier and resolve it to a URL.}exportasyncfunctionload(url, context, nextLoad) {// Take a resolved URL and return the source code to be evaluated.}copy

functionresolve(specifier, context, nextResolve) {// Take an `import` or `require` specifier and resolve it to a URL.}functionload(url, context, nextLoad) {// Take a resolved URL and return the source code to be evaluated.}copy

// path-to-my-hooks.jsexportasyncfunctioninitialize({ number, port }) {  port.postMessage(`increment:${number +1}`);}copy

import assertfrom'node:assert';import { register }from'node:module';import {MessageChannel }from'node:worker_threads';// This example showcases how a message channel can be used to communicate// between the main (application) thread and the hooks running on the hooks// thread, by sending `port2` to the `initialize` hook.const { port1, port2 } =newMessageChannel();port1.on('message',(msg) => {  assert.strictEqual(msg,'increment: 2');});port1.unref();register('./path-to-my-hooks.js', {parentURL:import.meta.url,data: {number:1,port: port2 },transferList: [port2],});const assert =require('node:assert');const { register } =require('node:module');const { pathToFileURL } =require('node:url');const {MessageChannel } =require('node:worker_threads');// This example showcases how a message channel can be used to communicate// between the main (application) thread and the hooks running on the hooks// thread, by sending `port2` to the `initialize` hook.const { port1, port2 } =newMessageChannel();port1.on('message',(msg) => {  assert.strictEqual(msg,'increment: 2');});port1.unref();register('./path-to-my-hooks.js', {parentURL:pathToFileURL(__filename),data: {number:1,port: port2 },transferList: [port2],});copy

// Asynchronous version accepted by module.register().exportasyncfunctionresolve(specifier, context, nextResolve) {const { parentURL =null } = context;if (Math.random() >0.5) {// Some condition.// For some or all specifiers, do some custom logic for resolving.// Always return an object of the form {url: <string>}.return {shortCircuit:true,url: parentURL ?newURL(specifier, parentURL).href :newURL(specifier).href,    };  }if (Math.random() <0.5) {// Another condition.// When calling `defaultResolve`, the arguments can be modified. In this// case it's adding another value for matching conditional exports.returnnextResolve(specifier, {      ...context,conditions: [...context.conditions,'another-condition'],    });  }// Defer to the next hook in the chain, which would be the// Node.js default resolve if this is the last user-specified loader.returnnextResolve(specifier);}copy

// Synchronous version accepted by module.registerHooks().functionresolve(specifier, context, nextResolve) {// Similar to the asynchronous resolve() above, since that one does not have// any asynchronous logic.}copy

import { readFile }from'node:fs/promises';// Asynchronous version accepted by module.register(). This fix is not needed// for the synchronous version accepted by module.registerHooks().exportasyncfunctionload(url, context, nextLoad) {const result =awaitnextLoad(url, context);if (result.format ==='commonjs') {    result.source ??=awaitreadFile(newURL(result.responseURL ?? url));  }return result;}copy

// Asynchronous version accepted by module.register().exportasyncfunctionload(url, context, nextLoad) {const { format } = context;if (Math.random() >0.5) {// Some condition/*      For some or all URLs, do some custom logic for retrieving the source.      Always return an object of the form {        format: <string>,        source: <string|buffer>,      }.    */return {      format,shortCircuit:true,source:'...',    };  }// Defer to the next hook in the chain.returnnextLoad(url);}copy

// Synchronous version accepted by module.registerHooks().functionload(url, context, nextLoad) {// Similar to the asynchronous load() above, since that one does not have// any asynchronous logic.}copy

Examples#

The various module customization hooks can be used together to accomplishwide-ranging customizations of the Node.js code loading and evaluationbehaviors.

// https-hooks.mjsimport { get }from'node:https';exportfunctionload(url, context, nextLoad) {// For JavaScript to be loaded over the network, we need to fetch and// return it.if (url.startsWith('https://')) {returnnewPromise((resolve, reject) => {get(url,(res) => {let data ='';        res.setEncoding('utf8');        res.on('data',(chunk) => data += chunk);        res.on('end',() =>resolve({// This example assumes all network-provided JavaScript is ES module// code.format:'module',shortCircuit:true,source: data,        }));      }).on('error',(err) =>reject(err));    });  }// Let Node.js handle all other URLs.returnnextLoad(url);}copy

// main.mjsimport {VERSION }from'https://coffeescript.org/browser-compiler-modern/coffeescript.js';console.log(VERSION);copy

// coffeescript-hooks.mjsimport { readFile }from'node:fs/promises';import { findPackageJSON }from'node:module';import coffeescriptfrom'coffeescript';const extensionsRegex =/\.(coffee|litcoffee|coffee\.md)$/;exportasyncfunctionload(url, context, nextLoad) {if (extensionsRegex.test(url)) {// CoffeeScript files can be either CommonJS or ES modules. Use a custom format// to tell Node.js not to detect its module type.const {source: rawSource } =awaitnextLoad(url, { ...context,format:'coffee' });// This hook converts CoffeeScript source code into JavaScript source code// for all imported CoffeeScript files.const transformedSource = coffeescript.compile(rawSource.toString(), url);// To determine how Node.js would interpret the transpilation result,// search up the file system for the nearest parent package.json file// and read its "type" field.return {format:awaitgetPackageType(url),shortCircuit:true,source: transformedSource,    };  }// Let Node.js handle all other URLs.returnnextLoad(url, context);}asyncfunctiongetPackageType(url) {// `url` is only a file path during the first iteration when passed the// resolved url from the load() hook// an actual file path from load() will contain a file extension as it's// required by the spec// this simple truthy check for whether `url` contains a file extension will// work for most projects but does not cover some edge-cases (such as// extensionless files or a url ending in a trailing space)const pJson =findPackageJSON(url);returnreadFile(pJson,'utf8')    .then(JSON.parse)    .then((json) => json?.type)    .catch(() =>undefined);}copy

// coffeescript-sync-hooks.mjsimport { readFileSync }from'node:fs';import { registerHooks, findPackageJSON }from'node:module';import coffeescriptfrom'coffeescript';const extensionsRegex =/\.(coffee|litcoffee|coffee\.md)$/;functionload(url, context, nextLoad) {if (extensionsRegex.test(url)) {const {source: rawSource } =nextLoad(url, { ...context,format:'coffee' });const transformedSource = coffeescript.compile(rawSource.toString(), url);return {format:getPackageType(url),shortCircuit:true,source: transformedSource,    };  }returnnextLoad(url, context);}functiongetPackageType(url) {const pJson =findPackageJSON(url);if (!pJson) {returnundefined;  }try {const file =readFileSync(pJson,'utf-8');returnJSON.parse(file)?.type;  }catch {returnundefined;  }}registerHooks({ load });copy

# main.coffeeimport { scream }from'./scream.coffee'console.log scream'hello, world'import { version }from'node:process'console.log"Brought to you by Node.js version#{version}"copy

# scream.coffeeexport scream =(str) -> str.toUpperCase()copy

{"type":"module"}copy

// import-map-hooks.jsimport fsfrom'node:fs/promises';const { imports } =JSON.parse(await fs.readFile('import-map.json'));exportasyncfunctionresolve(specifier, context, nextResolve) {if (Object.hasOwn(imports, specifier)) {returnnextResolve(imports[specifier], context);  }returnnextResolve(specifier, context);}copy

// import-map-sync-hooks.jsimport fsfrom'node:fs/promises';importmodulefrom'node:module';const { imports } =JSON.parse(fs.readFileSync('import-map.json','utf-8'));functionresolve(specifier, context, nextResolve) {if (Object.hasOwn(imports, specifier)) {returnnextResolve(imports[specifier], context);  }returnnextResolve(specifier, context);}module.registerHooks({ resolve });copy

// main.jsimport'a-module';copy

// import-map.json{"imports":{"a-module":"./some-module.js"}}copy

// some-module.jsconsole.log('some module!');copy

module.getSourceMapsSupport()#

• Returns:<Object>
  • enabled<boolean> If the source maps support is enabled
  • nodeModules<boolean> If the support is enabled for files innode_modules.
  • generatedCode<boolean> If the support is enabled for generated code fromeval ornew Function.

This method returns whether theSource Map v3 support for stacktraces is enabled.

module.findSourceMap(path)#

• path<string>
• Returns:<module.SourceMap> |<undefined> Returnsmodule.SourceMap if a sourcemap is found,undefined otherwise.

path is the resolved path for the file for which a corresponding source mapshould be fetched.

module.setSourceMapsSupport(enabled[, options])#

• enabled<boolean> Enable the source map support.
• options<Object> Optional
  • nodeModules<boolean> If enabling the support for files innode_modules.Default:false.
  • generatedCode<boolean> If enabling the support for generated code fromeval ornew Function.Default:false.

This function enables or disables theSource Map v3 support forstack traces.

It provides same features as launching Node.js process with commandline options--enable-source-maps, with additional options to alter the support for filesinnode_modules or generated codes.

Only source maps in JavaScript files that are loaded after source maps has beenenabled will be parsed and loaded. Preferably, use the commandline options--enable-source-maps to avoid losing track of source maps of modules loadedbefore this API call.

Class:module.SourceMap#