module — Deno 2 | Spec-Zone.ru

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

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

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

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

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

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.

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

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.

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

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.

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

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.

type alias Module.InitializeHook

Usage in Deno

import { Module } from "node:module";

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.

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";

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.

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";

import { Module } from "node:module";

import { require } from "node:module";

Type

Require