The std/node Library

The std/node part of the Deno standard library is a Node.js compatibility layer. Its primary focus is providing “polyfills” for Node’s built-in modules. It also provides a mechanism for loading CommonJS modules into Deno.

The library is most useful when trying to use your own or private code that was written for Node. If you are trying to consume public npm packages, you are likely to get a better result using a CDN.

Node.js built-in modules

The standard library provides several “replacement” modules for Node.js built-in modules. These either replicate the functionality of the built-in or they call the Deno native APIs, returning an interface that is compatible with Node.

The standard library provides modules for the following built-ins:

• assert
• assert/strict (partly)
• async_hooks (partly)
• buffer
• child_process (partly)
• cluster (partly)
• console (partly)
• constants
• crypto (partly)
• child_process (partly)
• dgram(partly)
• dns (partly)
• events
• fs (partly)
• fs/promises (partly)
• http (partly)
• http2 (partly)
• https (partly)
• inspector (partly)
• module
• net
• os (partly)
• path
• path/posix
• path/win32
• perf_hooks (partly)
• process (partly)
• punycode
• querystring
• readline
• repl (partly)
• stream
• stream/promises
• stream/web (partly)
• string_decoder
• sys
• timers
• timers/promises
• tty (partly)
• url
• util (partly)
• util/types (partly)
• vm (partly)
• wasi
• worker_threads

Following modules are not yet implemented:

• cluster
• dgram
• http2
• https
• repl
• tls
• vm
• zlib

If you try to run a Node.js code that requires any of the not implemented modules, please open an issue in https://github.com/denoland/deno_std/issues with example code.

In addition, there is the std/node/global.ts module which provides some of the Node.js globals like global, process, and Buffer.

If you want documentation for any of the modules, you can simply type deno doc and the URL of the module in your terminal:

> deno doc https://deno.land/std/fs/move.ts

Note that Node.js has some built-in modules (e.g. like vm) that are effectively incompatible with the scope of Deno and therefore there aren’t easy ways to provide a polyfill of the functionality in Deno.

Loading CommonJS modules

Current Node.js supports both CommonJS and ES Modules, while Deno only supports ES Modules. The addition of stabilized ES Modules in Node.js is relatively recent and most code written for Node.js is in the CommonJS format.

As mentioned above, for public npm packages, it is often better to use a CDN to transpile CommonJS modules to ES Modules for consumption by Deno. Not only do you get reliable conversion plus all the dependency resolution and management without requiring a package manager to install the packages on your local machine, you get the advantages of being able to share your code easier without requiring other users to setup some of the Node.js infrastructure to consume your code with Node.

That being said, the built-in Node.js module "module" provides a function named createRequire() which allows you to create a Node.js compatible require() function which can be used to load CommonJS modules, as well as use the same resolution logic that Node.js uses when trying to load a module. createRequire() will also install the Node.js globals for you.

Example usage would look like this:

import { createRequire } from "https://deno.land/std@0.167.0/node/module.ts";

// import.meta.url will be the location of "this" module (like `__filename` in
// Node), and then serve as the root for your "package", where the
// `package.json` is expected to be, and where the `node_modules` will be used
// for resolution of packages.
const require = createRequire(import.meta.url);

// Loads the built-in module Deno "replacement":
const path = require("path");

// Loads a CommonJS module (without specifying the extension):
const cjsModule = require("./my_mod");

// Uses Node.js resolution in `node_modules` to load the package/module. The
// package would need to be installed locally via a package management tool
// like npm:
const leftPad = require("left-pad");

When modules are loaded via the created require(), they are executed in a context which is similar to a Node.js context, which means that a lot of code written targeting Node.js will work.