Node

module

module

Usage in Deno

import * as mod from "node:module";

Classes

Module

No documentation available

Module.SourceMap

No documentation available

Functions

Module.createRequire

No documentation available

Module.enableCompileCache

Enable module compile cache in the current Node.js instance.

Module.findPackageJSON

// /path/to/project/packages/bar/bar.js
import { findPackageJSON } from 'node:module';

findPackageJSON('..', import.meta.url);
// '/path/to/project/package.json'
// Same result when passing an absolute specifier instead:
findPackageJSON(new URL('../', 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'

Module.findSourceMap

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

Module.flushCompileCache

Flush the module compile cache accumulated from modules already loaded in the current Node.js instance to disk. This returns after all the flushing file system operations come to an end, no matter they succeed or not. If there are any errors, this will fail silently, since compile cache misses should not interfere with the actual operation of the application.

Module.getCompileCacheDir

No documentation available

Module.isBuiltin

No documentation available

Module.register

Register a module that exports hooks that customize Node.js module resolution and loading behavior. See Customization hooks.

Module.runMain

No documentation available

Module.stripTypeScriptTypes

module.stripTypeScriptTypes() removes type annotations from TypeScript code. It can be used to strip type annotations from TypeScript code before running it with vm.runInContext() or vm.compileFunction(). By default, it will throw an error if the code contains TypeScript features that require transformation such as Enums, see type-stripping for more information. When mode is 'transform', it also transforms TypeScript features to JavaScript, see transform TypeScript features for more information. When mode is 'strip', source maps are not generated, because locations are preserved. If sourceMap is provided, when mode is 'strip', an error will be thrown.

Module.syncBuiltinESMExports

The module.syncBuiltinESMExports() method updates all the live bindings for builtin ES Modules to match the properties of the CommonJS exports. It does not add or remove exported names from the ES Modules.

Module.wrap

No documentation available

Interfaces

ImportMeta

No documentation available

Module.EnableCompileCacheResult

No documentation available

Module.ImportAttributes

No documentation available

type

Module.LoadFnOutput

No documentation available

Module.LoadHookContext

No documentation available

Module.RegisterOptions

No documentation available

Module.ResolveFnOutput

No documentation available

Module.ResolveHookContext

No documentation available

Module.SourceMapConstructorOptions

No documentation available

lineLengths

Module.SourceMapPayload

No documentation available

Module.SourceMapping

No documentation available

Module.SourceOrigin

No documentation available

Module.StripTypeScriptTypesOptions

No documentation available

Require

No documentation available

RequireResolve

No documentation available

paths

RequireResolveOptions

No documentation available

paths

NodeModule

No documentation available

NodeRequire

No documentation available

RequireExtensions

No documentation available

Namespaces

Module.constants

No documentation available

Module.constants.compileCacheStatus

The following constants are returned as the status field in the object returned by enableCompileCache to indicate the result of the attempt to enable the module compile cache.

Type Aliases

Module.InitializeHook

The initialize hook provides a way to define a custom function that runs in the hooks thread when the hooks module is initialized. Initialization happens when the hooks module is registered via register.

Module.LoadHook

The load hook provides a way to define a custom method of determining how a URL should be interpreted, retrieved, and parsed. It is also in charge of validating the import attributes.

Module.ModuleFormat

No documentation available

Module.ModuleSource

No documentation available

Module.ResolveHook

The resolve hook chain is responsible for telling Node.js where to find and how to cache a given import statement or expression, or require call. It can optionally return a format (such as 'module') as a hint to the load hook. If a format is specified, the load hook is ultimately responsible for providing the final format value (and it is free to ignore the hint provided by resolve); if resolve provides a format, a custom load hook is required even if only to pass the value to the Node.js default load hook.

Variables

__dirname

The directory name of the current module. This is the same as the path.dirname() of the __filename.

__filename

The file name of the current module. This is the current module file's absolute path with symlinks resolved.

exports

The exports variable is available within a module's file-level scope, and is assigned the value of module.exports before the module is evaluated.

module

A reference to the current module.

Module.builtinModules

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

Module.constants.compileCacheStatus.ALREADY_ENABLED

The compile cache has already been enabled before, either by a previous call to enableCompileCache, or by the NODE_COMPILE_CACHE=dir environment variable. The directory used to store the compile cache will be returned in the directory field in the returned object.

Module.constants.compileCacheStatus.DISABLED

Node.js cannot enable the compile cache because the environment variable NODE_DISABLE_COMPILE_CACHE=1 has been set.

Module.constants.compileCacheStatus.ENABLED

Node.js has enabled the compile cache successfully. The directory used to store the compile cache will be returned in the directory field in the returned object.

Module.constants.compileCacheStatus.FAILED

Node.js fails to enable the compile cache. This can be caused by the lack of permission to use the specified directory, or various kinds of file system errors. The detail of the failure will be returned in the message field in the returned object.

require

No documentation available

class Module

Usage in Deno

import { Module } from "node:module";

Deno compatibility

The register method is a non-functional stub.

Constructors #

#Module(id: string,
parent?: Module,
)

new

interface Module

extends [NodeJS.Module]

Deno compatibility

The register method is a non-functional stub.

Deno compatibility

The register method is a non-functional stub.

Properties #

#children: Module[]

The module objects required for the first time by this one.

#exports: any

The module.exports object is created by the Module system. Sometimes this is not acceptable; many want their module to be an instance of some class. To do this, assign the desired export object to module.exports.

#filename: string

The fully resolved filename of the module.

#id: string

The identifier for the module. Typically this is the fully resolved filename.

#isPreloading: boolean

true if the module is running during the Node.js preload phase.

#loaded: boolean

Whether or not the module is done loading, or is in the process of loading.

#parent: Module
 | null
 | undefined

deprecated

The module that first required this one, or null if the current module is the entry point of the current process, or undefined if the module was loaded by something that is not a CommonJS module (e.g. REPL or import).

#path: string

The directory name of the module. This is usually the same as the path.dirname() of the module.id.

#paths: string[]

The search paths for the module.

Methods #

#require(id: string): any

The module.require() method provides a way to load a module as if require() was called from the original module.

namespace Module

Deno compatibility

The register method is a non-functional stub.

Classes #

Module.SourceMap

No documentation available

Functions #

Module.createRequire

No documentation available

Module.enableCompileCache

Enable module compile cache in the current Node.js instance.

Module.findPackageJSON

// /path/to/project/packages/bar/bar.js
import { findPackageJSON } from 'node:module';

findPackageJSON('..', import.meta.url);
// '/path/to/project/package.json'
// Same result when passing an absolute specifier instead:
findPackageJSON(new URL('../', 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'

Module.findSourceMap

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

Module.flushCompileCache

Module.getCompileCacheDir

No documentation available

Module.isBuiltin

No documentation available

Module.register

Register a module that exports hooks that customize Node.js module resolution and loading behavior. See Customization hooks.

Module.runMain

No documentation available

Module.stripTypeScriptTypes

Module.syncBuiltinESMExports

Module.wrap

No documentation available

Interfaces #

Module.EnableCompileCacheResult

No documentation available

Module.ImportAttributes

No documentation available

type

Module.LoadFnOutput

No documentation available

Module.LoadHookContext

No documentation available

Module.RegisterOptions

No documentation available

Module.ResolveFnOutput

No documentation available

Module.ResolveHookContext

No documentation available

Module.SourceMapConstructorOptions

No documentation available

lineLengths

Module.SourceMapPayload

No documentation available

Module.SourceMapping

No documentation available

Module.SourceOrigin

No documentation available

Module.StripTypeScriptTypesOptions

No documentation available

Namespaces #

Module.constants

No documentation available

Type Aliases #

Module.InitializeHook

Module.LoadHook

The load hook provides a way to define a custom method of determining how a URL should be interpreted, retrieved, and parsed. It is also in charge of validating the import attributes.

Module.ModuleFormat

No documentation available

Module.ModuleSource

No documentation available

Module.ResolveHook

Variables #

Module.builtinModules

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

class Module.SourceMap

Usage in Deno

import { Module } from "node:module";

Constructors #

#SourceMap(payload: SourceMapPayload,
options?: SourceMapConstructorOptions,
)

new

Properties #

#payload: SourceMapPayload

readonly

Getter for the payload used to construct the SourceMap instance.

Methods #

#findEntry(lineOffset: number,
columnOffset: number,
): SourceMapping | {  }

Given a line offset and column offset in the generated source file, returns an object representing the SourceMap range in the original file if found, or an empty object if not.

The object returned contains the following keys:

The returned value represents the raw range as it appears in the SourceMap, based on zero-indexed offsets, not 1-indexed line and column numbers as they appear in Error messages and CallSite objects.

To get the corresponding 1-indexed line and column numbers from a lineNumber and columnNumber as they are reported by Error stacks and CallSite objects, use sourceMap.findOrigin(lineNumber, columnNumber)

#findOrigin(lineNumber: number,
columnNumber: number,
): SourceOrigin | {  }

Given a 1-indexed lineNumber and columnNumber from a call site in the generated source, find the corresponding call site location in the original source.

If the lineNumber and columnNumber provided are not found in any source map, then an empty object is returned.

function Module.createRequire

Usage in Deno

import { Module } from "node:module";

#createRequire(path: string | URL): Require

Parameters #

#path: string | URL

Filename to be used to construct the require function. Must be a file URL object, file URL string, or absolute path string.

Return Type #

Require

function Module.enableCompileCache

Usage in Deno

import { Module } from "node:module";

#enableCompileCache(cacheDir?: string): EnableCompileCacheResult

Enable module compile cache in the current Node.js instance.

If cacheDir is not specified, Node.js will either use the directory specified by the NODE_COMPILE_CACHE=dir environment variable if it's set, or use path.join(os.tmpdir(), 'node-compile-cache') otherwise. For general use cases, it's recommended to call module.enableCompileCache() without specifying the cacheDir, so that the directory can be overridden by the NODE_COMPILE_CACHE environment variable when necessary.

Since compile cache is supposed to be a quiet optimization that is not required for the application to be functional, this method is designed to not throw any exception when the compile cache cannot be enabled. Instead, it will return an object containing an error message in the message field to aid debugging. If compile cache is enabled successfully, the directory field in the returned object contains the path to the directory where the compile cache is stored. The status field in the returned object would be one of the module.constants.compileCacheStatus values 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, either call this method in child worker threads too, or set the process.env.NODE_COMPILE_CACHE value to compile cache directory so the behavior can be inherited into the child workers. The directory can be obtained either from the directory field returned by this method, or with getCompileCacheDir.

Parameters #

#cacheDir: string

optional

Optional path to specify the directory where the compile cache will be stored/retrieved.

Return Type #

EnableCompileCacheResult

function Module.findPackageJSON

Usage in Deno

import { Module } from "node:module";

#findPackageJSON(specifier: string | URL,
base?: string | URL,
): string | undefined

/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'

// /path/to/project/packages/bar/bar.js
import { findPackageJSON } from 'node:module';

findPackageJSON('..', import.meta.url);
// '/path/to/project/package.json'
// Same result when passing an absolute specifier instead:
findPackageJSON(new URL('../', 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'

Parameters #

#specifier: string | URL

The specifier for the module whose package.json to retrieve. When passing a bare specifier, the package.json at the root of the package is returned. When passing a relative specifier or an absolute specifier, the closest parent package.json is returned.

#base: string | URL

optional

The absolute location (file: URL string or FS path) of the containing module. For CJS, use __filename (not __dirname!); for ESM, use import.meta.url. You do not need to pass it if specifier is an absolute specifier.

Return Type #

string | undefined

A path if the package.json is found. When startLocation is a package, the package's root package.json; when a relative or unresolved, the closest package.json to the startLocation.

function Module.findSourceMap

Usage in Deno

import { Module } from "node:module";

#findSourceMap(path: string): SourceMap | undefined

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

Parameters #

#path: string

Return Type #

SourceMap | undefined

Returns module.SourceMap if a source map is found, undefined otherwise.

function Module.flushCompileCache

Usage in Deno

import { Module } from "node:module";

#flushCompileCache(): void

Return Type #

void

function Module.getCompileCacheDir

Usage in Deno

import { Module } from "node:module";

#getCompileCacheDir(): string | undefined

Return Type #

string | undefined

Path to the module compile cache directory if it is enabled, or undefined otherwise.

function Module.isBuiltin

Usage in Deno

import { Module } from "node:module";

#isBuiltin(moduleName: string): boolean

Parameters #

#moduleName: string

Return Type #

boolean

function Module.register

Usage in Deno

import { Module } from "node:module";

Overload 1

#register<Data = any>(specifier: string | URL,
parentURL?: string | URL,
options?: RegisterOptions<Data>,
): void

Register a module that exports hooks that customize Node.js module resolution and loading behavior. See Customization hooks.

This feature requires --allow-worker if used with the Permission Model.

Type Parameters #

#Data = any

Parameters #

#specifier: string | URL

Customization hooks to be registered; this should be the same string that would be passed to import(), except that if it is relative, it is resolved relative to parentURL.

#parentURL: string | URL

optional

f you want to resolve specifier relative to a base URL, such as import.meta.url, you can pass that URL here.

#options: RegisterOptions<Data>

optional

Return Type #

void

Overload 2

#register<Data = any>(specifier: string | URL,
options?: RegisterOptions<Data>,
): void

Type Parameters #

#Data = any

Parameters #

#specifier: string | URL

#options: RegisterOptions<Data>

optional

Return Type #

void

function Module.runMain

Usage in Deno

import { Module } from "node:module";

#runMain(main?: string): void

Parameters #

#main: string

optional

Return Type #

void

function Module.stripTypeScriptTypes

Usage in Deno

import { Module } from "node:module";

#stripTypeScriptTypes(code: string,
options?: StripTypeScriptTypesOptions,
): string

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;

If sourceUrl 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;

When mode is 'transform', the code is transformed to JavaScript:

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, ...

Parameters #

#code: string

The code to strip type annotations from.

#options: StripTypeScriptTypesOptions

optional

Return Type #

string

The code with type annotations stripped.

function Module.syncBuiltinESMExports

Usage in Deno

import { Module } from "node:module";

#syncBuiltinESMExports(): void

import fs from 'node:fs';
import assert from 'node:assert';
import { syncBuiltinESMExports } from 'node:module';

fs.readFile = newAPI;

delete fs.readFileSync;

function newAPI() {
  // ...
}

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);
});

Return Type #

void

function Module.wrap

Usage in Deno

import { Module } from "node:module";

#wrap(script: string): string

Parameters #

#script: string

Return Type #

string

interface ImportMeta

Usage in Deno

import { type ImportMeta } from "node:module";

Properties #

#dirname: string

The directory name of the current module. This is the same as the path.dirname() of the import.meta.filename. Caveat: only present on file: modules.

#filename: string

The full absolute path and filename of the current module, with symlinks resolved. This is the same as the url.fileURLToPath() of the import.meta.url. Caveat: only local modules support this property. Modules not using the file: protocol will not provide it.

#url: string

The absolute file: URL of the module.

Methods #

#resolve(specifier: string,
parent?: string
 | URL
 | undefined,
): string

Provides a module-relative resolution function scoped to each module, returning the URL string.

Second parent parameter is only used when the --experimental-import-meta-resolve command flag enabled.

interface Module.EnableCompileCacheResult

Usage in Deno

import { Module } from "node:module";

Properties #

#status: number

One of the constants.compileCacheStatus

#message: string

optional

If Node.js cannot enable the compile cache, this contains the error message. Only set if status is module.constants.compileCacheStatus.FAILED.

#directory: string

optional

If the compile cache is enabled, this contains the directory where the compile cache is stored. Only set if status is module.constants.compileCacheStatus.ENABLED or module.constants.compileCacheStatus.ALREADY_ENABLED.

interface Module.ImportAttributes

extends [NodeJS.Dict]<string>

Usage in Deno

import { Module } from "node:module";

Properties #

#type: string | undefined

optional

interface Module.LoadFnOutput

Usage in Deno

import { Module } from "node:module";

Properties #

#format: ModuleFormat

#shortCircuit: boolean | undefined

optional

A signal that this hook intends to terminate the chain of resolve hooks.

#source: ModuleSource | undefined

optional

The source for Node.js to evaluate

interface Module.LoadHookContext

Usage in Deno

import { Module } from "node:module";

Properties #

#conditions: string[]

Export conditions of the relevant package.json

#format: string
 | null
 | undefined

The format optionally supplied by the resolve hook chain (can be an intermediary value).

#importAttributes: ImportAttributes

An object whose key-value pairs represent the assertions for the module to import

interface Module.RegisterOptions

Usage in Deno

import { Module } from "node:module";

Type Parameters #

#Data

Properties #

#parentURL: string
 | URL
 | undefined

optional

If you want to resolve specifier relative to a base URL, such as import.meta.url, you can pass that URL here. This property is ignored if the parentURL is supplied as the second argument.

#data: Data | undefined

optional

Any arbitrary, cloneable JavaScript value to pass into the initialize hook.

#transferList: any[] | undefined

optional

Transferable objects to be passed into the initialize hook.

interface Module.ResolveFnOutput

Usage in Deno

import { Module } from "node:module";

Properties #

#format: string
 | null
 | undefined

optional

A hint to the load hook (it might be ignored); can be an intermediary value.

#importAttributes: ImportAttributes | undefined

optional

The import attributes to use when caching the module (optional; if excluded the input will be used)

#shortCircuit: boolean | undefined

optional

A signal that this hook intends to terminate the chain of resolve hooks.

#url: string

The absolute URL to which this input resolves

interface Module.ResolveHookContext

Usage in Deno

import { Module } from "node:module";

Properties #

#conditions: string[]

Export conditions of the relevant package.json

#importAttributes: ImportAttributes

An object whose key-value pairs represent the assertions for the module to import

#parentURL: string | undefined

The module importing this one, or undefined if this is the Node.js entry point

interface Module.SourceMapConstructorOptions

Usage in Deno

import { Module } from "node:module";

Properties #

#lineLengths: readonly number[] | undefined

optional

interface Module.SourceMapPayload

Usage in Deno

import { Module } from "node:module";

Properties #

#file: string

#version: number

#sources: string[]

#sourcesContent: string[]

#names: string[]

#mappings: string

#sourceRoot: string

interface Module.SourceMapping

Usage in Deno

import { Module } from "node:module";

Properties #

#generatedLine: number

#generatedColumn: number

#originalSource: string

#originalLine: number

#originalColumn: number

interface Module.SourceOrigin

Usage in Deno

import { Module } from "node:module";

Properties #

#name: string | undefined

The name of the range in the source map, if one was provided

#fileName: string

The file name of the original source, as reported in the SourceMap

#lineNumber: number

The 1-indexed lineNumber of the corresponding call site in the original source

#columnNumber: number

The 1-indexed columnNumber of the corresponding call site in the original source

interface Module.StripTypeScriptTypesOptions

Usage in Deno

import { Module } from "node:module";

Properties #

#mode: "strip"
 | "transform"
 | undefined

optional

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 | undefined

optional

Only when mode is 'transform', if true, a source map will be generated for the transformed code.

#sourceUrl: string | undefined

optional

Specifies the source url used in the source map.

interface Require

Usage in Deno

import { type Require } from "node:module";

Call Signatures #

(id: string): any

Used to import modules, JSON, and local files.

Properties #

#cache: Dict<Module>

Modules are cached in this object when they are required. By deleting a key value from this object, the next require will reload the module. This does not apply to native addons, for which reloading will result in an error.

#extensions: RequireExtensions

deprecated

Instruct require on how to handle certain file extensions.

#main: Module | undefined

The Module object representing the entry script loaded when the Node.js process launched, or undefined if the entry point of the program is not a CommonJS module.

#resolve: RequireResolve

interface RequireResolve

Usage in Deno

import { type RequireResolve } from "node:module";

Call Signatures #

(request: string,
options?: RequireResolveOptions,
): string

Use the internal require() machinery to look up the location of a module, but rather than loading the module, just return the resolved filename.

If the module can not be found, a MODULE_NOT_FOUND error is thrown.

Methods #

#paths(request: string): string[] | null

Returns an array containing the paths searched during resolution of request or null if the request string references a core module, for example http or fs.

interface RequireResolveOptions

Usage in Deno

import { type RequireResolveOptions } from "node:module";

Properties #

#paths: string[] | undefined

optional

Paths to resolve module location from. If present, these paths are used instead of the default resolution paths, with the exception of GLOBAL_FOLDERS like $HOME/.node_modules, which are always included. Each of these paths is used as a starting point for the module resolution algorithm, meaning that the node_modules hierarchy is checked from this location.

interface NodeModule

extends [NodeJS.Module]

Usage in Deno

import { type NodeModule } from "node:module";

Deprecated

Use NodeJS.Module instead.

interface NodeRequire

extends [NodeJS.Require]

Usage in Deno

import { type NodeRequire } from "node:module";

Deprecated

Use NodeJS.Require instead.

interface RequireExtensions

extends Dict<(

module: Module,

filename: string,

) => any>

Usage in Deno

import { type RequireExtensions } from "node:module";

Properties #

#.js: (module: Module,
filename: string,
) => any

#.json: (module: Module,
filename: string,
) => any

#.node: (module: Module,
filename: string,
) => any

namespace Module.constants

Usage in Deno

import { Module } from "node:module";

Namespaces #

Module.constants.compileCacheStatus

The following constants are returned as the status field in the object returned by enableCompileCache to indicate the result of the attempt to enable the module compile cache.

namespace Module.constants.compileCacheStatus

Usage in Deno

import { Module } from "node:module";

The following constants are returned as the status field in the object returned by enableCompileCache to indicate the result of the attempt to enable the module compile cache.

Variables #

Module.constants.compileCacheStatus.ALREADY_ENABLED

Module.constants.compileCacheStatus.DISABLED

Node.js cannot enable the compile cache because the environment variable NODE_DISABLE_COMPILE_CACHE=1 has been set.

Module.constants.compileCacheStatus.ENABLED

Node.js has enabled the compile cache successfully. The directory used to store the compile cache will be returned in the directory field in the returned object.

Module.constants.compileCacheStatus.FAILED

type alias Module.InitializeHook

Usage in Deno

import { Module } from "node:module";

This hook can receive data from a register invocation, including ports and other transferable objects. The return value of initialize can be a Promise, in which case it will be awaited before the main application thread execution resumes.

Type Parameters #

#Data = any

Definition #

(data: Data) => void | Promise<void>

type alias Module.LoadHook

Usage in Deno

import { Module } from "node:module";

The load hook provides a way to define a custom method of determining how a URL should be interpreted, retrieved, and parsed. It is also in charge of validating the import attributes.

Definition #

(url: string,
context: LoadHookContext,
nextLoad: (url: string,
context?: Partial<LoadHookContext>,
) => LoadFnOutput | Promise<LoadFnOutput>,
) => LoadFnOutput | Promise<LoadFnOutput>

type alias Module.ModuleFormat

Usage in Deno

import { Module } from "node:module";

Definition #

"builtin"
 | "commonjs"
 | "commonjs-typescript"
 | "json"
 | "module"
 | "module-typescript"
 | "wasm"

type alias Module.ModuleSource

Usage in Deno

import { Module } from "node:module";

Definition #

string
 | ArrayBuffer
 | TypedArray

type alias Module.ResolveHook

Usage in Deno

import { Module } from "node:module";

Definition #

(specifier: string,
context: ResolveHookContext,
nextResolve: (specifier: string,
context?: Partial<ResolveHookContext>,
) => ResolveFnOutput | Promise<ResolveFnOutput>,
) => ResolveFnOutput | Promise<ResolveFnOutput>

variable __dirname

Usage in Deno

import { __dirname } from "node:module";

The directory name of the current module. This is the same as the path.dirname() of the __filename.

Type #

string

variable __filename

Usage in Deno

import { __filename } from "node:module";

The file name of the current module. This is the current module file's absolute path with symlinks resolved.

For a main program this is not necessarily the same as the file name used in the command line.

Type #

string

variable exports

Usage in Deno

import { exports } from "node:module";

The exports variable is available within a module's file-level scope, and is assigned the value of module.exports before the module is evaluated.

Type #

Module["exports"]

variable module

Usage in Deno

import { module } from "node:module";

A reference to the current module.

Type #

Module

variable Module.builtinModules

Usage in Deno

import { Module } from "node:module";

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

Note: the list doesn't contain prefix-only modules like node:test.

Type #

readonly string[]

variable Module.constants.compileCacheStatus.ALREADY_ENABLED

Usage in Deno

import { Module } from "node:module";

Type #

number

variable Module.constants.compileCacheStatus.DISABLED

Usage in Deno

import { Module } from "node:module";

Node.js cannot enable the compile cache because the environment variable NODE_DISABLE_COMPILE_CACHE=1 has been set.

Type #

number

variable Module.constants.compileCacheStatus.ENABLED

Usage in Deno

import { Module } from "node:module";

Node.js has enabled the compile cache successfully. The directory used to store the compile cache will be returned in the directory field in the returned object.

Type #

number

variable Module.constants.compileCacheStatus.FAILED

Usage in Deno

import { Module } from "node:module";

Type #

number

variable require

Usage in Deno

import { require } from "node:module";

Type #

Require