...

{
 "type": "module",
 "source": "doc/api/assert.md",
 "modules": [
 {
 "textRaw": "Assert",
 "name": "assert",
 "introduced_in": "v0.1.21",
 "stability": 2,
 "stabilityText": "Stable",
 "desc": "Source Code: <a href=\"https://github.com/nodejs/node/blob/v16.20.2/lib/assert.js\">lib/assert.js</a>\nThe <code>node:assert</code> module provides a set of assertion functions for verifying\ninvariants.",
 "modules": [
 {
 "textRaw": "Strict assertion mode",
 "name": "strict_assertion_mode",
 "meta": {
 "added": [
 "v9.9.0"
 ],
 "changes": [
 {
 "version": "v15.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/34001",
 "description": "Exposed as `require('node:assert/strict')`."
 },
 {
 "version": [
 "v13.9.0",
 "v12.16.2"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/31635",
 "description": "Changed \"strict mode\" to \"strict assertion mode\" and \"legacy mode\" to \"legacy assertion mode\" to avoid confusion with the more usual meaning of \"strict mode\"."
 },
 {
 "version": "v9.9.0",
 "pr-url": "https://github.com/nodejs/node/pull/17615",
 "description": "Added error diffs to the strict assertion mode."
 },
 {
 "version": "v9.9.0",
 "pr-url": "https://github.com/nodejs/node/pull/17002",
 "description": "Added strict assertion mode to the assert module."
 }
 ]
 },
 "desc": "In strict assertion mode, non-strict methods behave like their corresponding\nstrict methods. For example, <a href=\"#assertdeepequalactual-expected-message\"><code>assert.deepEqual()</code></a> will behave like\n<a href=\"#assertdeepstrictequalactual-expected-message\"><code>assert.deepStrictEqual()</code></a>.\nIn strict assertion mode, error messages for objects display a diff. In legacy\nassertion mode, error messages for objects display the objects, often truncated.\nTo use strict assertion mode:\n<pre><code class=\"language-mjs\">import { strict as assert } from 'node:assert';\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert').strict;\n</code></pre>\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n</code></pre>\nExample error diff:\n<pre><code class=\"language-mjs\">import { strict as assert } from 'node:assert';\n\nassert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected ... Lines skipped\n//\n// [\n// [\n// ...\n// 2,\n// + 3\n// - '3'\n// ],\n// ...\n// 5\n// ]\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected ... Lines skipped\n//\n// [\n// [\n// ...\n// 2,\n// + 3\n// - '3'\n// ],\n// ...\n// 5\n// ]\n</code></pre>\nTo deactivate the colors, use the <code>NO_COLOR</code> or <code>NODE_DISABLE_COLORS</code>\nenvironment variables. This will also deactivate the colors in the REPL. For\nmore on color support in terminal environments, read the tty\n<a href=\"tty.html#writestreamgetcolordepthenv\"><code>getColorDepth()</code></a> documentation.",
 "type": "module",
 "displayName": "Strict assertion mode"
 },
 {
 "textRaw": "Legacy assertion mode",
 "name": "legacy_assertion_mode",
 "desc": "Legacy assertion mode uses the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality\"><code>==</code> operator</a> in:\n<ul>\n<li><a href=\"#assertdeepequalactual-expected-message\"><code>assert.deepEqual()</code></a></li>\n<li><a href=\"#assertequalactual-expected-message\"><code>assert.equal()</code></a></li>\n<li><a href=\"#assertnotdeepequalactual-expected-message\"><code>assert.notDeepEqual()</code></a></li>\n<li><a href=\"#assertnotequalactual-expected-message\"><code>assert.notEqual()</code></a></li>\n</ul>\nTo use legacy assertion mode:\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n</code></pre>\nLegacy assertion mode may have surprising results, especially when using\n<a href=\"#assertdeepequalactual-expected-message\"><code>assert.deepEqual()</code></a>:\n<pre><code class=\"language-cjs\">// WARNING: This does not throw an AssertionError in legacy assertion mode!\nassert.deepEqual(/a/gi, new Date());\n</code></pre>",
 "type": "module",
 "displayName": "Legacy assertion mode"
 }
 ],
 "classes": [
 {
 "textRaw": "Class: assert.AssertionError",
 "type": "class",
 "name": "assert.AssertionError",
 "desc": "<ul>\n<li>Extends: <a href=\"errors.html#class-error\" class=\"type\">&lt;errors.Error&gt;</a></li>\n</ul>\nIndicates the failure of an assertion. All errors thrown by the <code>node:assert</code>\nmodule will be instances of the <code>AssertionError</code> class.",
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`options` {Object}",
 "name": "options",
 "type": "Object",
 "options": [
 {
 "textRaw": "`message` {string} If provided, the error message is set to this value.",
 "name": "message",
 "type": "string",
 "desc": "If provided, the error message is set to this value."
 },
 {
 "textRaw": "`actual` {any} The `actual` property on the error instance.",
 "name": "actual",
 "type": "any",
 "desc": "The `actual` property on the error instance."
 },
 {
 "textRaw": "`expected` {any} The `expected` property on the error instance.",
 "name": "expected",
 "type": "any",
 "desc": "The `expected` property on the error instance."
 },
 {
 "textRaw": "`operator` {string} The `operator` property on the error instance.",
 "name": "operator",
 "type": "string",
 "desc": "The `operator` property on the error instance."
 },
 {
 "textRaw": "`stackStartFn` {Function} If provided, the generated stack trace omits frames before this function.",
 "name": "stackStartFn",
 "type": "Function",
 "desc": "If provided, the generated stack trace omits frames before this function."
 }
 ]
 }
 ],
 "desc": "A subclass of <code>Error</code> that indicates the failure of an assertion.\nAll instances contain the built-in <code>Error</code> properties (<code>message</code> and <code>name</code>)\nand:\n<ul>\n<li><code>actual</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types\" class=\"type\">&lt;any&gt;</a> Set to the <code>actual</code> argument for methods such as\n<a href=\"#assertstrictequalactual-expected-message\"><code>assert.strictEqual()</code></a>.</li>\n<li><code>expected</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types\" class=\"type\">&lt;any&gt;</a> Set to the <code>expected</code> value for methods such as\n<a href=\"#assertstrictequalactual-expected-message\"><code>assert.strictEqual()</code></a>.</li>\n<li><code>generatedMessage</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type\" class=\"type\">&lt;boolean&gt;</a> Indicates if the message was auto-generated\n(<code>true</code>) or not.</li>\n<li><code>code</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Value is always <code>ERR_ASSERTION</code> to show that the error is an\nassertion error.</li>\n<li><code>operator</code> <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type\" class=\"type\">&lt;string&gt;</a> Set to the passed in operator value.</li>\n</ul>\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\n// Generate an AssertionError to compare the error message later:\nconst { message } = new assert.AssertionError({\n actual: 1,\n expected: 2,\n operator: 'strictEqual'\n});\n\n// Verify error output:\ntry {\n assert.strictEqual(1, 2);\n} catch (err) {\n assert(err instanceof assert.AssertionError);\n assert.strictEqual(err.message, message);\n assert.strictEqual(err.name, 'AssertionError');\n assert.strictEqual(err.actual, 1);\n assert.strictEqual(err.expected, 2);\n assert.strictEqual(err.code, 'ERR_ASSERTION');\n assert.strictEqual(err.operator, 'strictEqual');\n assert.strictEqual(err.generatedMessage, true);\n}\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\n// Generate an AssertionError to compare the error message later:\nconst { message } = new assert.AssertionError({\n actual: 1,\n expected: 2,\n operator: 'strictEqual'\n});\n\n// Verify error output:\ntry {\n assert.strictEqual(1, 2);\n} catch (err) {\n assert(err instanceof assert.AssertionError);\n assert.strictEqual(err.message, message);\n assert.strictEqual(err.name, 'AssertionError');\n assert.strictEqual(err.actual, 1);\n assert.strictEqual(err.expected, 2);\n assert.strictEqual(err.code, 'ERR_ASSERTION');\n assert.strictEqual(err.operator, 'strictEqual');\n assert.strictEqual(err.generatedMessage, true);\n}\n</code></pre>"
 }
 ]
 },
 {
 "textRaw": "Class: `assert.CallTracker`",
 "type": "class",
 "name": "assert.CallTracker",
 "meta": {
 "added": [
 "v14.2.0",
 "v12.19.0"
 ],
 "changes": []
 },
 "stability": 1,
 "stabilityText": "Experimental",
 "desc": "This feature is currently experimental and behavior might still change.",
 "methods": [
 {
 "textRaw": "`tracker.calls([fn][, exact])`",
 "type": "method",
 "name": "calls",
 "meta": {
 "added": [
 "v14.2.0",
 "v12.19.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {Function} that wraps `fn`.",
 "name": "return",
 "type": "Function",
 "desc": "that wraps `fn`."
 },
 "params": [
 {
 "textRaw": "`fn` {Function} **Default:** A no-op function.",
 "name": "fn",
 "type": "Function",
 "default": "A no-op function"
 },
 {
 "textRaw": "`exact` {number} **Default:** `1`.",
 "name": "exact",
 "type": "number",
 "default": "`1`"
 }
 ]
 }
 ],
 "desc": "The wrapper function is expected to be called exactly <code>exact</code> times. If the\nfunction has not been called exactly <code>exact</code> times when\n<a href=\"#trackerverify\"><code>tracker.verify()</code></a> is called, then <a href=\"#trackerverify\"><code>tracker.verify()</code></a> will throw an\nerror.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\n// Creates call tracker.\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// Returns a function that wraps func() that must be called exact times\n// before tracker.verify().\nconst callsfunc = tracker.calls(func);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\n// Creates call tracker.\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// Returns a function that wraps func() that must be called exact times\n// before tracker.verify().\nconst callsfunc = tracker.calls(func);\n</code></pre>"
 },
 {
 "textRaw": "`tracker.getCalls(fn)`",
 "type": "method",
 "name": "getCalls",
 "meta": {
 "added": [
 "v16.18.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {Array} with all the calls to a tracked function.",
 "name": "return",
 "type": "Array",
 "desc": "with all the calls to a tracked function."
 },
 "params": [
 {
 "textRaw": "`fn` {Function}.",
 "name": "fn",
 "type": "Function",
 "desc": "."
 },
 {
 "textRaw": "Object {Object}",
 "name": "Object",
 "type": "Object",
 "options": [
 {
 "textRaw": "`thisArg` {Object}",
 "name": "thisArg",
 "type": "Object"
 },
 {
 "textRaw": "`arguments` {Array} the arguments passed to the tracked function",
 "name": "arguments",
 "type": "Array",
 "desc": "the arguments passed to the tracked function"
 }
 ]
 }
 ]
 }
 ],
 "desc": "<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\nconst callsfunc = tracker.calls(func);\ncallsfunc(1, 2, 3);\n\nassert.deepStrictEqual(tracker.getCalls(callsfunc),\n [{ thisArg: this, arguments: [1, 2, 3 ] }]);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\n// Creates call tracker.\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\nconst callsfunc = tracker.calls(func);\ncallsfunc(1, 2, 3);\n\nassert.deepStrictEqual(tracker.getCalls(callsfunc),\n [{ thisArg: this, arguments: [1, 2, 3 ] }]);\n</code></pre>"
 },
 {
 "textRaw": "`tracker.report()`",
 "type": "method",
 "name": "report",
 "meta": {
 "added": [
 "v14.2.0",
 "v12.19.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {Array} of objects containing information about the wrapper functions returned by [`tracker.calls()`][].",
 "name": "return",
 "type": "Array",
 "desc": "of objects containing information about the wrapper functions returned by [`tracker.calls()`][]."
 },
 "params": [
 {
 "textRaw": "Object {Object}",
 "name": "Object",
 "type": "Object",
 "options": [
 {
 "textRaw": "`message` {string}",
 "name": "message",
 "type": "string"
 },
 {
 "textRaw": "`actual` {number} The actual number of times the function was called.",
 "name": "actual",
 "type": "number",
 "desc": "The actual number of times the function was called."
 },
 {
 "textRaw": "`expected` {number} The number of times the function was expected to be called.",
 "name": "expected",
 "type": "number",
 "desc": "The number of times the function was expected to be called."
 },
 {
 "textRaw": "`operator` {string} The name of the function that is wrapped.",
 "name": "operator",
 "type": "string",
 "desc": "The name of the function that is wrapped."
 },
 {
 "textRaw": "`stack` {Object} A stack trace of the function.",
 "name": "stack",
 "type": "Object",
 "desc": "A stack trace of the function."
 }
 ]
 }
 ]
 }
 ],
 "desc": "The arrays contains information about the expected and actual number of calls of\nthe functions that have not been called the expected number of times.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\n// Creates call tracker.\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// Returns a function that wraps func() that must be called exact times\n// before tracker.verify().\nconst callsfunc = tracker.calls(func, 2);\n\n// Returns an array containing information on callsfunc()\ntracker.report();\n// [\n// {\n// message: 'Expected the func function to be executed 2 time(s) but was\n// executed 0 time(s).',\n// actual: 0,\n// expected: 2,\n// operator: 'func',\n// stack: stack trace\n// }\n// ]\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\n// Creates call tracker.\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// Returns a function that wraps func() that must be called exact times\n// before tracker.verify().\nconst callsfunc = tracker.calls(func, 2);\n\n// Returns an array containing information on callsfunc()\ntracker.report();\n// [\n// {\n// message: 'Expected the func function to be executed 2 time(s) but was\n// executed 0 time(s).',\n// actual: 0,\n// expected: 2,\n// operator: 'func',\n// stack: stack trace\n// }\n// ]\n</code></pre>"
 },
 {
 "textRaw": "`tracker.reset([fn])`",
 "type": "method",
 "name": "reset",
 "meta": {
 "added": [
 "v16.18.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`fn` {Function} a tracked function to reset.",
 "name": "fn",
 "type": "Function",
 "desc": "a tracked function to reset."
 }
 ]
 }
 ],
 "desc": "reset calls of the call tracker.\nif a tracked function is passed as an argument, the calls will be reset for it.\nif no arguments are passed, all tracked functions will be reset\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\nconst callsfunc = tracker.calls(func);\n\ncallsfunc();\n// Tracker was called once\ntracker.getCalls(callsfunc).length === 1;\n\ntracker.reset(callsfunc);\ntracker.getCalls(callsfunc).length === 0;\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\nfunction func() {}\nconst callsfunc = tracker.calls(func);\n\ncallsfunc();\n// Tracker was called once\ntracker.getCalls(callsfunc).length === 1;\n\ntracker.reset(callsfunc);\ntracker.getCalls(callsfunc).length === 0;\n</code></pre>"
 },
 {
 "textRaw": "`tracker.verify()`",
 "type": "method",
 "name": "verify",
 "meta": {
 "added": [
 "v14.2.0",
 "v12.19.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": []
 }
 ],
 "desc": "Iterates through the list of functions passed to\n<a href=\"#trackercallsfn-exact\"><code>tracker.calls()</code></a> and will throw an error for functions that\nhave not been called the expected number of times.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\n// Creates call tracker.\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// Returns a function that wraps func() that must be called exact times\n// before tracker.verify().\nconst callsfunc = tracker.calls(func, 2);\n\ncallsfunc();\n\n// Will throw an error since callsfunc() was only called once.\ntracker.verify();\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\n// Creates call tracker.\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// Returns a function that wraps func() that must be called exact times\n// before tracker.verify().\nconst callsfunc = tracker.calls(func, 2);\n\ncallsfunc();\n\n// Will throw an error since callsfunc() was only called once.\ntracker.verify();\n</code></pre>"
 }
 ],
 "signatures": [
 {
 "params": [],
 "desc": "Creates a new <a href=\"#class-assertcalltracker\"><code>CallTracker</code></a> object which can be used to track if functions\nwere called a specific number of times. The <code>tracker.verify()</code> must be called\nfor the verification to take place. The usual pattern would be to call it in a\n<a href=\"process.html#event-exit\"><code>process.on('exit')</code></a> handler.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\nimport process from 'node:process';\n\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// callsfunc() must be called exactly 1 time before tracker.verify().\nconst callsfunc = tracker.calls(func, 1);\n\ncallsfunc();\n\n// Calls tracker.verify() and verifies if all tracker.calls() functions have\n// been called exact times.\nprocess.on('exit', () => {\n tracker.verify();\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\nconst tracker = new assert.CallTracker();\n\nfunction func() {}\n\n// callsfunc() must be called exactly 1 time before tracker.verify().\nconst callsfunc = tracker.calls(func, 1);\n\ncallsfunc();\n\n// Calls tracker.verify() and verifies if all tracker.calls() functions have\n// been called exact times.\nprocess.on('exit', () => {\n tracker.verify();\n});\n</code></pre>"
 }
 ]
 }
 ],
 "methods": [
 {
 "textRaw": "`assert(value[, message])`",
 "type": "method",
 "name": "assert",
 "meta": {
 "added": [
 "v0.5.9"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`value` {any} The input that is checked for being truthy.",
 "name": "value",
 "type": "any",
 "desc": "The input that is checked for being truthy."
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "An alias of <a href=\"#assertokvalue-message\"><code>assert.ok()</code></a>."
 },
 {
 "textRaw": "`assert.deepEqual(actual, expected[, message])`",
 "type": "method",
 "name": "deepEqual",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v16.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/38113",
 "description": "In Legacy assertion mode, changed status from Deprecated to Legacy."
 },
 {
 "version": "v14.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/30766",
 "description": "NaN is now treated as being identical if both sides are NaN."
 },
 {
 "version": "v12.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/25008",
 "description": "The type tags are now properly compared and there are a couple minor comparison adjustments to make the check less surprising."
 },
 {
 "version": "v9.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/15001",
 "description": "The `Error` names and messages are now properly compared."
 },
 {
 "version": "v8.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/12142",
 "description": "The `Set` and `Map` content is also compared."
 },
 {
 "version": [
 "v6.4.0",
 "v4.7.1"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/8002",
 "description": "Typed array slices are handled correctly now."
 },
 {
 "version": [
 "v6.1.0",
 "v4.5.0"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/6432",
 "description": "Objects with circular references can be used as inputs now."
 },
 {
 "version": [
 "v5.10.1",
 "v4.4.3"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/5910",
 "description": "Handle non-`Uint8Array` typed arrays correctly."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Strict assertion mode\nAn alias of <a href=\"#assertdeepstrictequalactual-expected-message\"><code>assert.deepStrictEqual()</code></a>.\nLegacy assertion mode\n<blockquote>\nStability: 3 - Legacy: Use <a href=\"#assertdeepstrictequalactual-expected-message\"><code>assert.deepStrictEqual()</code></a> instead.\n</blockquote>\nTests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider\nusing <a href=\"#assertdeepstrictequalactual-expected-message\"><code>assert.deepStrictEqual()</code></a> instead. <a href=\"#assertdeepequalactual-expected-message\"><code>assert.deepEqual()</code></a> can have\nsurprising results.\nDeep equality means that the enumerable \"own\" properties of child objects\nare also recursively evaluated by the following rules.",
 "modules": [
 {
 "textRaw": "Comparison details",
 "name": "comparison_details",
 "desc": "<ul>\n<li>Primitive values are compared with the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality\"><code>==</code> operator</a>,\nwith the exception of <code>NaN</code>. It is treated as being identical in case\nboth sides are <code>NaN</code>.</li>\n<li><a href=\"https://tc39.github.io/ecma262/#sec-object.prototype.tostring\">Type tags</a> of objects should be the same.</li>\n<li>Only <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties\">enumerable \"own\" properties</a> are considered.</li>\n<li><a href=\"errors.html#class-error\"><code>Error</code></a> names and messages are always compared, even if these are not\nenumerable properties.</li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Glossary/Primitive#Primitive_wrapper_objects_in_JavaScript\">Object wrappers</a> are compared both as objects and unwrapped values.</li>\n<li><code>Object</code> properties are compared unordered.</li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\"><code>Map</code></a> keys and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set\"><code>Set</code></a> items are compared unordered.</li>\n<li>Recursion stops when both sides differ or both sides encounter a circular\nreference.</li>\n<li>Implementation does not test the <a href=\"https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots\"><code>[[Prototype]]</code></a> of\nobjects.</li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol\"><code>Symbol</code></a> properties are not compared.</li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap\"><code>WeakMap</code></a> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> comparison does not rely on their values.</li>\n</ul>\nThe following example does not throw an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> because the\nprimitives are compared using the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality\"><code>==</code> operator</a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n// WARNING: This does not throw an AssertionError!\n\nassert.deepEqual('+00000000', false);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n// WARNING: This does not throw an AssertionError!\n\nassert.deepEqual('+00000000', false);\n</code></pre>\n\"Deep\" equality means that the enumerable \"own\" properties of child objects\nare evaluated also:\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\nconst obj1 = {\n a: {\n b: 1\n }\n};\nconst obj2 = {\n a: {\n b: 2\n }\n};\nconst obj3 = {\n a: {\n b: 1\n }\n};\nconst obj4 = Object.create(obj1);\n\nassert.deepEqual(obj1, obj1);\n// OK\n\n// Values of b are different:\nassert.deepEqual(obj1, obj2);\n// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }\n\nassert.deepEqual(obj1, obj3);\n// OK\n\n// Prototypes are ignored:\nassert.deepEqual(obj1, obj4);\n// AssertionError: { a: { b: 1 } } deepEqual {}\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\nconst obj1 = {\n a: {\n b: 1\n }\n};\nconst obj2 = {\n a: {\n b: 2\n }\n};\nconst obj3 = {\n a: {\n b: 1\n }\n};\nconst obj4 = Object.create(obj1);\n\nassert.deepEqual(obj1, obj1);\n// OK\n\n// Values of b are different:\nassert.deepEqual(obj1, obj2);\n// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }\n\nassert.deepEqual(obj1, obj3);\n// OK\n\n// Prototypes are ignored:\nassert.deepEqual(obj1, obj4);\n// AssertionError: { a: { b: 1 } } deepEqual {}\n</code></pre>\nIf the values are not equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a <code>message</code>\nproperty set equal to the value of the <code>message</code> parameter. If the <code>message</code>\nparameter is undefined, a default error message is assigned. If the <code>message</code>\nparameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown instead of the\n<a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>.",
 "type": "module",
 "displayName": "Comparison details"
 }
 ]
 },
 {
 "textRaw": "`assert.deepStrictEqual(actual, expected[, message])`",
 "type": "method",
 "name": "deepStrictEqual",
 "meta": {
 "added": [
 "v1.2.0"
 ],
 "changes": [
 {
 "version": "v9.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/15169",
 "description": "Enumerable symbol properties are now compared."
 },
 {
 "version": "v9.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/15036",
 "description": "The `NaN` is now compared using the [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero) comparison."
 },
 {
 "version": "v8.5.0",
 "pr-url": "https://github.com/nodejs/node/pull/15001",
 "description": "The `Error` names and messages are now properly compared."
 },
 {
 "version": "v8.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/12142",
 "description": "The `Set` and `Map` content is also compared."
 },
 {
 "version": [
 "v6.4.0",
 "v4.7.1"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/8002",
 "description": "Typed array slices are handled correctly now."
 },
 {
 "version": "v6.1.0",
 "pr-url": "https://github.com/nodejs/node/pull/6432",
 "description": "Objects with circular references can be used as inputs now."
 },
 {
 "version": [
 "v5.10.1",
 "v4.4.3"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/5910",
 "description": "Handle non-`Uint8Array` typed arrays correctly."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters.\n\"Deep\" equality means that the enumerable \"own\" properties of child objects\nare recursively evaluated also by the following rules.",
 "modules": [
 {
 "textRaw": "Comparison details",
 "name": "comparison_details",
 "desc": "<ul>\n<li>Primitive values are compared using <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\"><code>Object.is()</code></a>.</li>\n<li><a href=\"https://tc39.github.io/ecma262/#sec-object.prototype.tostring\">Type tags</a> of objects should be the same.</li>\n<li><a href=\"https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots\"><code>[[Prototype]]</code></a> of objects are compared using\nthe <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality\"><code>===</code> operator</a>.</li>\n<li>Only <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties\">enumerable \"own\" properties</a> are considered.</li>\n<li><a href=\"errors.html#class-error\"><code>Error</code></a> names and messages are always compared, even if these are not\nenumerable properties.</li>\n<li>Enumerable own <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol\"><code>Symbol</code></a> properties are compared as well.</li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Glossary/Primitive#Primitive_wrapper_objects_in_JavaScript\">Object wrappers</a> are compared both as objects and unwrapped values.</li>\n<li><code>Object</code> properties are compared unordered.</li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\"><code>Map</code></a> keys and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set\"><code>Set</code></a> items are compared unordered.</li>\n<li>Recursion stops when both sides differ or both sides encounter a circular\nreference.</li>\n<li><a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap\"><code>WeakMap</code></a> and <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\"><code>WeakSet</code></a> comparison does not rely on their values. See\nbelow for further details.</li>\n</ul>\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\n// This fails because 1 !== '1'.\nassert.deepStrictEqual({ a: 1 }, { a: '1' });\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// {\n// + a: 1\n// - a: '1'\n// }\n\n// The following objects don't have own properties\nconst date = new Date();\nconst object = {};\nconst fakeDate = {};\nObject.setPrototypeOf(fakeDate, Date.prototype);\n\n// Different [[Prototype]]:\nassert.deepStrictEqual(object, fakeDate);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + {}\n// - Date {}\n\n// Different type tags:\nassert.deepStrictEqual(date, fakeDate);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + 2018-04-26T00:49:08.604Z\n// - Date {}\n\nassert.deepStrictEqual(NaN, NaN);\n// OK because Object.is(NaN, NaN) is true.\n\n// Different unwrapped numbers:\nassert.deepStrictEqual(new Number(1), new Number(2));\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + [Number: 1]\n// - [Number: 2]\n\nassert.deepStrictEqual(new String('foo'), Object('foo'));\n// OK because the object and the string are identical when unwrapped.\n\nassert.deepStrictEqual(-0, -0);\n// OK\n\n// Different zeros:\nassert.deepStrictEqual(0, -0);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + 0\n// - -0\n\nconst symbol1 = Symbol();\nconst symbol2 = Symbol();\nassert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });\n// OK, because it is the same symbol on both objects.\n\nassert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });\n// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:\n//\n// {\n// [Symbol()]: 1\n// }\n\nconst weakMap1 = new WeakMap();\nconst weakMap2 = new WeakMap([[{}, {}]]);\nconst weakMap3 = new WeakMap();\nweakMap3.unequal = true;\n\nassert.deepStrictEqual(weakMap1, weakMap2);\n// OK, because it is impossible to compare the entries\n\n// Fails because weakMap3 has a property that weakMap1 does not contain:\nassert.deepStrictEqual(weakMap1, weakMap3);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// WeakMap {\n// + [items unknown]\n// - [items unknown],\n// - unequal: true\n// }\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\n// This fails because 1 !== '1'.\nassert.deepStrictEqual({ a: 1 }, { a: '1' });\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// {\n// + a: 1\n// - a: '1'\n// }\n\n// The following objects don't have own properties\nconst date = new Date();\nconst object = {};\nconst fakeDate = {};\nObject.setPrototypeOf(fakeDate, Date.prototype);\n\n// Different [[Prototype]]:\nassert.deepStrictEqual(object, fakeDate);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + {}\n// - Date {}\n\n// Different type tags:\nassert.deepStrictEqual(date, fakeDate);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + 2018-04-26T00:49:08.604Z\n// - Date {}\n\nassert.deepStrictEqual(NaN, NaN);\n// OK because Object.is(NaN, NaN) is true.\n\n// Different unwrapped numbers:\nassert.deepStrictEqual(new Number(1), new Number(2));\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + [Number: 1]\n// - [Number: 2]\n\nassert.deepStrictEqual(new String('foo'), Object('foo'));\n// OK because the object and the string are identical when unwrapped.\n\nassert.deepStrictEqual(-0, -0);\n// OK\n\n// Different zeros:\nassert.deepStrictEqual(0, -0);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// + 0\n// - -0\n\nconst symbol1 = Symbol();\nconst symbol2 = Symbol();\nassert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });\n// OK, because it is the same symbol on both objects.\n\nassert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });\n// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:\n//\n// {\n// [Symbol()]: 1\n// }\n\nconst weakMap1 = new WeakMap();\nconst weakMap2 = new WeakMap([[{}, {}]]);\nconst weakMap3 = new WeakMap();\nweakMap3.unequal = true;\n\nassert.deepStrictEqual(weakMap1, weakMap2);\n// OK, because it is impossible to compare the entries\n\n// Fails because weakMap3 has a property that weakMap1 does not contain:\nassert.deepStrictEqual(weakMap1, weakMap3);\n// AssertionError: Expected inputs to be strictly deep-equal:\n// + actual - expected\n//\n// WeakMap {\n// + [items unknown]\n// - [items unknown],\n// - unequal: true\n// }\n</code></pre>\nIf the values are not equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a <code>message</code>\nproperty set equal to the value of the <code>message</code> parameter. If the <code>message</code>\nparameter is undefined, a default error message is assigned. If the <code>message</code>\nparameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.",
 "type": "module",
 "displayName": "Comparison details"
 }
 ]
 },
 {
 "textRaw": "`assert.doesNotMatch(string, regexp[, message])`",
 "type": "method",
 "name": "doesNotMatch",
 "meta": {
 "added": [
 "v13.6.0",
 "v12.16.0"
 ],
 "changes": [
 {
 "version": "v16.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/38111",
 "description": "This API is no longer experimental."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`string` {string}",
 "name": "string",
 "type": "string"
 },
 {
 "textRaw": "`regexp` {RegExp}",
 "name": "regexp",
 "type": "RegExp"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Expects the <code>string</code> input not to match the regular expression.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.doesNotMatch('I will fail', /fail/);\n// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...\n\nassert.doesNotMatch(123, /pass/);\n// AssertionError [ERR_ASSERTION]: The \"string\" argument must be of type string.\n\nassert.doesNotMatch('I will pass', /different/);\n// OK\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.doesNotMatch('I will fail', /fail/);\n// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...\n\nassert.doesNotMatch(123, /pass/);\n// AssertionError [ERR_ASSERTION]: The \"string\" argument must be of type string.\n\nassert.doesNotMatch('I will pass', /different/);\n// OK\n</code></pre>\nIf the values do match, or if the <code>string</code> argument is of another type than\n<code>string</code>, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal\nto the value of the <code>message</code> parameter. If the <code>message</code> parameter is\nundefined, a default error message is assigned. If the <code>message</code> parameter is an\ninstance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown instead of the\n<a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>."
 },
 {
 "textRaw": "`assert.doesNotReject(asyncFn[, error][, message])`",
 "type": "method",
 "name": "doesNotReject",
 "meta": {
 "added": [
 "v10.0.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`asyncFn` {Function|Promise}",
 "name": "asyncFn",
 "type": "Function|Promise"
 },
 {
 "textRaw": "`error` {RegExp|Function}",
 "name": "error",
 "type": "RegExp|Function"
 },
 {
 "textRaw": "`message` {string}",
 "name": "message",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "Awaits the <code>asyncFn</code> promise or, if <code>asyncFn</code> is a function, immediately\ncalls the function and awaits the returned promise to complete. It will then\ncheck that the promise is not rejected.\nIf <code>asyncFn</code> is a function and it throws an error synchronously,\n<code>assert.doesNotReject()</code> will return a rejected <code>Promise</code> with that error. If\nthe function does not return a promise, <code>assert.doesNotReject()</code> will return a\nrejected <code>Promise</code> with an <a href=\"errors.html#err_invalid_return_value\"><code>ERR_INVALID_RETURN_VALUE</code></a> error. In both cases\nthe error handler is skipped.\nUsing <code>assert.doesNotReject()</code> is actually not useful because there is little\nbenefit in catching a rejection and then rejecting it again. Instead, consider\nadding a comment next to the specific code path that should not reject and keep\nerror messages as expressive as possible.\nIf specified, <code>error</code> can be a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes\"><code>Class</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\"><code>RegExp</code></a>, or a validation\nfunction. See <a href=\"#assertthrowsfn-error-message\"><code>assert.throws()</code></a> for more details.\nBesides the async nature to await the completion behaves identically to\n<a href=\"#assertdoesnotthrowfn-error-message\"><code>assert.doesNotThrow()</code></a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nawait assert.doesNotReject(\n async () => {\n throw new TypeError('Wrong value');\n },\n SyntaxError\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\n(async () => {\n await assert.doesNotReject(\n async () => {\n throw new TypeError('Wrong value');\n },\n SyntaxError\n );\n})();\n</code></pre>\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.doesNotReject(Promise.reject(new TypeError('Wrong value')))\n .then(() => {\n // ...\n });\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.doesNotReject(Promise.reject(new TypeError('Wrong value')))\n .then(() => {\n // ...\n });\n</code></pre>"
 },
 {
 "textRaw": "`assert.doesNotThrow(fn[, error][, message])`",
 "type": "method",
 "name": "doesNotThrow",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": [
 "v5.11.0",
 "v4.4.5"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/2407",
 "description": "The `message` parameter is respected now."
 },
 {
 "version": "v4.2.0",
 "pr-url": "https://github.com/nodejs/node/pull/3276",
 "description": "The `error` parameter can now be an arrow function."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`fn` {Function}",
 "name": "fn",
 "type": "Function"
 },
 {
 "textRaw": "`error` {RegExp|Function}",
 "name": "error",
 "type": "RegExp|Function"
 },
 {
 "textRaw": "`message` {string}",
 "name": "message",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "Asserts that the function <code>fn</code> does not throw an error.\nUsing <code>assert.doesNotThrow()</code> is actually not useful because there\nis no benefit in catching an error and then rethrowing it. Instead, consider\nadding a comment next to the specific code path that should not throw and keep\nerror messages as expressive as possible.\nWhen <code>assert.doesNotThrow()</code> is called, it will immediately call the <code>fn</code>\nfunction.\nIf an error is thrown and it is the same type as that specified by the <code>error</code>\nparameter, then an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown. If the error is of a\ndifferent type, or if the <code>error</code> parameter is undefined, the error is\npropagated back to the caller.\nIf specified, <code>error</code> can be a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes\"><code>Class</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\"><code>RegExp</code></a>, or a validation\nfunction. See <a href=\"#assertthrowsfn-error-message\"><code>assert.throws()</code></a> for more details.\nThe following, for instance, will throw the <a href=\"errors.html#class-typeerror\"><code>TypeError</code></a> because there is no\nmatching error type in the assertion:\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n SyntaxError\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n SyntaxError\n);\n</code></pre>\nHowever, the following will result in an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> with the message\n'Got unwanted exception...':\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n TypeError\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n TypeError\n);\n</code></pre>\nIf an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown and a value is provided for the <code>message</code>\nparameter, the value of <code>message</code> will be appended to the <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>\nmessage:\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n /Wrong value/,\n 'Whoops'\n);\n// Throws: AssertionError: Got unwanted exception: Whoops\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.doesNotThrow(\n () => {\n throw new TypeError('Wrong value');\n },\n /Wrong value/,\n 'Whoops'\n);\n// Throws: AssertionError: Got unwanted exception: Whoops\n</code></pre>"
 },
 {
 "textRaw": "`assert.equal(actual, expected[, message])`",
 "type": "method",
 "name": "equal",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v16.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/38113",
 "description": "In Legacy assertion mode, changed status from Deprecated to Legacy."
 },
 {
 "version": "v14.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/30766",
 "description": "NaN is now treated as being identical if both sides are NaN."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Strict assertion mode\nAn alias of <a href=\"#assertstrictequalactual-expected-message\"><code>assert.strictEqual()</code></a>.\nLegacy assertion mode\n<blockquote>\nStability: 3 - Legacy: Use <a href=\"#assertstrictequalactual-expected-message\"><code>assert.strictEqual()</code></a> instead.\n</blockquote>\nTests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters\nusing the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality\"><code>==</code> operator</a>. <code>NaN</code> is specially handled\nand treated as being identical if both sides are <code>NaN</code>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\nassert.equal(1, 1);\n// OK, 1 == 1\nassert.equal(1, '1');\n// OK, 1 == '1'\nassert.equal(NaN, NaN);\n// OK\n\nassert.equal(1, 2);\n// AssertionError: 1 == 2\nassert.equal({ a: { b: 1 } }, { a: { b: 1 } });\n// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\nassert.equal(1, 1);\n// OK, 1 == 1\nassert.equal(1, '1');\n// OK, 1 == '1'\nassert.equal(NaN, NaN);\n// OK\n\nassert.equal(1, 2);\n// AssertionError: 1 == 2\nassert.equal({ a: { b: 1 } }, { a: { b: 1 } });\n// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }\n</code></pre>\nIf the values are not equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a <code>message</code>\nproperty set equal to the value of the <code>message</code> parameter. If the <code>message</code>\nparameter is undefined, a default error message is assigned. If the <code>message</code>\nparameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>."
 },
 {
 "textRaw": "`assert.fail([message])`",
 "type": "method",
 "name": "fail",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`message` {string|Error} **Default:** `'Failed'`",
 "name": "message",
 "type": "string|Error",
 "default": "`'Failed'`"
 }
 ]
 }
 ],
 "desc": "Throws an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> with the provided error message or a default\nerror message. If the <code>message</code> parameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then\nit will be thrown instead of the <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.fail();\n// AssertionError [ERR_ASSERTION]: Failed\n\nassert.fail('boom');\n// AssertionError [ERR_ASSERTION]: boom\n\nassert.fail(new TypeError('need array'));\n// TypeError: need array\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.fail();\n// AssertionError [ERR_ASSERTION]: Failed\n\nassert.fail('boom');\n// AssertionError [ERR_ASSERTION]: boom\n\nassert.fail(new TypeError('need array'));\n// TypeError: need array\n</code></pre>\nUsing <code>assert.fail()</code> with more than two arguments is possible but deprecated.\nSee below for further details."
 },
 {
 "textRaw": "`assert.fail(actual, expected[, message[, operator[, stackStartFn]]])`",
 "type": "method",
 "name": "fail",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v10.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/18418",
 "description": "Calling `assert.fail()` with more than one argument is deprecated and emits a warning."
 }
 ]
 },
 "stability": 0,
 "stabilityText": "Deprecated: Use `assert.fail([message])` or other assert\nfunctions instead.",
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 },
 {
 "textRaw": "`operator` {string} **Default:** `'!='`",
 "name": "operator",
 "type": "string",
 "default": "`'!='`"
 },
 {
 "textRaw": "`stackStartFn` {Function} **Default:** `assert.fail`",
 "name": "stackStartFn",
 "type": "Function",
 "default": "`assert.fail`"
 }
 ]
 }
 ],
 "desc": "If <code>message</code> is falsy, the error message is set as the values of <code>actual</code> and\n<code>expected</code> separated by the provided <code>operator</code>. If just the two <code>actual</code> and\n<code>expected</code> arguments are provided, <code>operator</code> will default to <code>'!='</code>. If\n<code>message</code> is provided as third argument it will be used as the error message and\nthe other arguments will be stored as properties on the thrown object. If\n<code>stackStartFn</code> is provided, all stack frames above that function will be\nremoved from stacktrace (see <a href=\"errors.html#errorcapturestacktracetargetobject-constructoropt\"><code>Error.captureStackTrace</code></a>). If no arguments are\ngiven, the default message <code>Failed</code> will be used.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.fail('a', 'b');\n// AssertionError [ERR_ASSERTION]: 'a' != 'b'\n\nassert.fail(1, 2, undefined, '>');\n// AssertionError [ERR_ASSERTION]: 1 > 2\n\nassert.fail(1, 2, 'fail');\n// AssertionError [ERR_ASSERTION]: fail\n\nassert.fail(1, 2, 'whoops', '>');\n// AssertionError [ERR_ASSERTION]: whoops\n\nassert.fail(1, 2, new TypeError('need array'));\n// TypeError: need array\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.fail('a', 'b');\n// AssertionError [ERR_ASSERTION]: 'a' != 'b'\n\nassert.fail(1, 2, undefined, '>');\n// AssertionError [ERR_ASSERTION]: 1 > 2\n\nassert.fail(1, 2, 'fail');\n// AssertionError [ERR_ASSERTION]: fail\n\nassert.fail(1, 2, 'whoops', '>');\n// AssertionError [ERR_ASSERTION]: whoops\n\nassert.fail(1, 2, new TypeError('need array'));\n// TypeError: need array\n</code></pre>\nIn the last three cases <code>actual</code>, <code>expected</code>, and <code>operator</code> have no\ninfluence on the error message.\nExample use of <code>stackStartFn</code> for truncating the exception's stacktrace:\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nfunction suppressFrame() {\n assert.fail('a', 'b', undefined, '!==', suppressFrame);\n}\nsuppressFrame();\n// AssertionError [ERR_ASSERTION]: 'a' !== 'b'\n// at repl:1:1\n// at ContextifyScript.Script.runInThisContext (vm.js:44:33)\n// ...\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nfunction suppressFrame() {\n assert.fail('a', 'b', undefined, '!==', suppressFrame);\n}\nsuppressFrame();\n// AssertionError [ERR_ASSERTION]: 'a' !== 'b'\n// at repl:1:1\n// at ContextifyScript.Script.runInThisContext (vm.js:44:33)\n// ...\n</code></pre>"
 },
 {
 "textRaw": "`assert.ifError(value)`",
 "type": "method",
 "name": "ifError",
 "meta": {
 "added": [
 "v0.1.97"
 ],
 "changes": [
 {
 "version": "v10.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/18247",
 "description": "Instead of throwing the original error it is now wrapped into an [`AssertionError`][] that contains the full stack trace."
 },
 {
 "version": "v10.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/18247",
 "description": "Value may now only be `undefined` or `null`. Before all falsy values were handled the same as `null` and did not throw."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`value` {any}",
 "name": "value",
 "type": "any"
 }
 ]
 }
 ],
 "desc": "Throws <code>value</code> if <code>value</code> is not <code>undefined</code> or <code>null</code>. This is useful when\ntesting the <code>error</code> argument in callbacks. The stack trace contains all frames\nfrom the error passed to <code>ifError()</code> including the potential new frames for\n<code>ifError()</code> itself.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.ifError(null);\n// OK\nassert.ifError(0);\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0\nassert.ifError('error');\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'\nassert.ifError(new Error());\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error\n\n// Create some random error frames.\nlet err;\n(function errorFrame() {\n err = new Error('test error');\n})();\n\n(function ifErrorFrame() {\n assert.ifError(err);\n})();\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error\n// at ifErrorFrame\n// at errorFrame\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.ifError(null);\n// OK\nassert.ifError(0);\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0\nassert.ifError('error');\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'\nassert.ifError(new Error());\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error\n\n// Create some random error frames.\nlet err;\n(function errorFrame() {\n err = new Error('test error');\n})();\n\n(function ifErrorFrame() {\n assert.ifError(err);\n})();\n// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error\n// at ifErrorFrame\n// at errorFrame\n</code></pre>"
 },
 {
 "textRaw": "`assert.match(string, regexp[, message])`",
 "type": "method",
 "name": "match",
 "meta": {
 "added": [
 "v13.6.0",
 "v12.16.0"
 ],
 "changes": [
 {
 "version": "v16.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/38111",
 "description": "This API is no longer experimental."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`string` {string}",
 "name": "string",
 "type": "string"
 },
 {
 "textRaw": "`regexp` {RegExp}",
 "name": "regexp",
 "type": "RegExp"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Expects the <code>string</code> input to match the regular expression.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.match('I will fail', /pass/);\n// AssertionError [ERR_ASSERTION]: The input did not match the regular ...\n\nassert.match(123, /pass/);\n// AssertionError [ERR_ASSERTION]: The \"string\" argument must be of type string.\n\nassert.match('I will pass', /pass/);\n// OK\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.match('I will fail', /pass/);\n// AssertionError [ERR_ASSERTION]: The input did not match the regular ...\n\nassert.match(123, /pass/);\n// AssertionError [ERR_ASSERTION]: The \"string\" argument must be of type string.\n\nassert.match('I will pass', /pass/);\n// OK\n</code></pre>\nIf the values do not match, or if the <code>string</code> argument is of another type than\n<code>string</code>, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal\nto the value of the <code>message</code> parameter. If the <code>message</code> parameter is\nundefined, a default error message is assigned. If the <code>message</code> parameter is an\ninstance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown instead of the\n<a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>."
 },
 {
 "textRaw": "`assert.notDeepEqual(actual, expected[, message])`",
 "type": "method",
 "name": "notDeepEqual",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v16.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/38113",
 "description": "In Legacy assertion mode, changed status from Deprecated to Legacy."
 },
 {
 "version": "v14.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/30766",
 "description": "NaN is now treated as being identical if both sides are NaN."
 },
 {
 "version": "v9.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/15001",
 "description": "The `Error` names and messages are now properly compared."
 },
 {
 "version": "v8.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/12142",
 "description": "The `Set` and `Map` content is also compared."
 },
 {
 "version": [
 "v6.4.0",
 "v4.7.1"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/8002",
 "description": "Typed array slices are handled correctly now."
 },
 {
 "version": [
 "v6.1.0",
 "v4.5.0"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/6432",
 "description": "Objects with circular references can be used as inputs now."
 },
 {
 "version": [
 "v5.10.1",
 "v4.4.3"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/5910",
 "description": "Handle non-`Uint8Array` typed arrays correctly."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Strict assertion mode\nAn alias of <a href=\"#assertnotdeepstrictequalactual-expected-message\"><code>assert.notDeepStrictEqual()</code></a>.\nLegacy assertion mode\n<blockquote>\nStability: 3 - Legacy: Use <a href=\"#assertnotdeepstrictequalactual-expected-message\"><code>assert.notDeepStrictEqual()</code></a> instead.\n</blockquote>\nTests for any deep inequality. Opposite of <a href=\"#assertdeepequalactual-expected-message\"><code>assert.deepEqual()</code></a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\nconst obj1 = {\n a: {\n b: 1\n }\n};\nconst obj2 = {\n a: {\n b: 2\n }\n};\nconst obj3 = {\n a: {\n b: 1\n }\n};\nconst obj4 = Object.create(obj1);\n\nassert.notDeepEqual(obj1, obj1);\n// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }\n\nassert.notDeepEqual(obj1, obj2);\n// OK\n\nassert.notDeepEqual(obj1, obj3);\n// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }\n\nassert.notDeepEqual(obj1, obj4);\n// OK\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\nconst obj1 = {\n a: {\n b: 1\n }\n};\nconst obj2 = {\n a: {\n b: 2\n }\n};\nconst obj3 = {\n a: {\n b: 1\n }\n};\nconst obj4 = Object.create(obj1);\n\nassert.notDeepEqual(obj1, obj1);\n// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }\n\nassert.notDeepEqual(obj1, obj2);\n// OK\n\nassert.notDeepEqual(obj1, obj3);\n// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }\n\nassert.notDeepEqual(obj1, obj4);\n// OK\n</code></pre>\nIf the values are deeply equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a\n<code>message</code> property set equal to the value of the <code>message</code> parameter. If the\n<code>message</code> parameter is undefined, a default error message is assigned. If the\n<code>message</code> parameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown\ninstead of the <code>AssertionError</code>."
 },
 {
 "textRaw": "`assert.notDeepStrictEqual(actual, expected[, message])`",
 "type": "method",
 "name": "notDeepStrictEqual",
 "meta": {
 "added": [
 "v1.2.0"
 ],
 "changes": [
 {
 "version": "v9.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/15398",
 "description": "The `-0` and `+0` are not considered equal anymore."
 },
 {
 "version": "v9.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/15036",
 "description": "The `NaN` is now compared using the [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero) comparison."
 },
 {
 "version": "v9.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/15001",
 "description": "The `Error` names and messages are now properly compared."
 },
 {
 "version": "v8.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/12142",
 "description": "The `Set` and `Map` content is also compared."
 },
 {
 "version": [
 "v6.4.0",
 "v4.7.1"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/8002",
 "description": "Typed array slices are handled correctly now."
 },
 {
 "version": "v6.1.0",
 "pr-url": "https://github.com/nodejs/node/pull/6432",
 "description": "Objects with circular references can be used as inputs now."
 },
 {
 "version": [
 "v5.10.1",
 "v4.4.3"
 ],
 "pr-url": "https://github.com/nodejs/node/pull/5910",
 "description": "Handle non-`Uint8Array` typed arrays correctly."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Tests for deep strict inequality. Opposite of <a href=\"#assertdeepstrictequalactual-expected-message\"><code>assert.deepStrictEqual()</code></a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.notDeepStrictEqual({ a: 1 }, { a: '1' });\n// OK\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.notDeepStrictEqual({ a: 1 }, { a: '1' });\n// OK\n</code></pre>\nIf the values are deeply and strictly equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown\nwith a <code>message</code> property set equal to the value of the <code>message</code> parameter. If\nthe <code>message</code> parameter is undefined, a default error message is assigned. If\nthe <code>message</code> parameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown\ninstead of the <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>."
 },
 {
 "textRaw": "`assert.notEqual(actual, expected[, message])`",
 "type": "method",
 "name": "notEqual",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v16.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/38113",
 "description": "In Legacy assertion mode, changed status from Deprecated to Legacy."
 },
 {
 "version": "v14.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/30766",
 "description": "NaN is now treated as being identical if both sides are NaN."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Strict assertion mode\nAn alias of <a href=\"#assertnotstrictequalactual-expected-message\"><code>assert.notStrictEqual()</code></a>.\nLegacy assertion mode\n<blockquote>\nStability: 3 - Legacy: Use <a href=\"#assertnotstrictequalactual-expected-message\"><code>assert.notStrictEqual()</code></a> instead.\n</blockquote>\nTests shallow, coercive inequality with the <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Inequality\"><code>!=</code> operator</a>. <code>NaN</code> is\nspecially handled and treated as being identical if both sides are <code>NaN</code>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert';\n\nassert.notEqual(1, 2);\n// OK\n\nassert.notEqual(1, 1);\n// AssertionError: 1 != 1\n\nassert.notEqual(1, '1');\n// AssertionError: 1 != '1'\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\nassert.notEqual(1, 2);\n// OK\n\nassert.notEqual(1, 1);\n// AssertionError: 1 != 1\n\nassert.notEqual(1, '1');\n// AssertionError: 1 != '1'\n</code></pre>\nIf the values are equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a <code>message</code>\nproperty set equal to the value of the <code>message</code> parameter. If the <code>message</code>\nparameter is undefined, a default error message is assigned. If the <code>message</code>\nparameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>."
 },
 {
 "textRaw": "`assert.notStrictEqual(actual, expected[, message])`",
 "type": "method",
 "name": "notStrictEqual",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v10.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/17003",
 "description": "Used comparison changed from Strict Equality to `Object.is()`."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Tests strict inequality between the <code>actual</code> and <code>expected</code> parameters as\ndetermined by <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\"><code>Object.is()</code></a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.notStrictEqual(1, 2);\n// OK\n\nassert.notStrictEqual(1, 1);\n// AssertionError [ERR_ASSERTION]: Expected \"actual\" to be strictly unequal to:\n//\n// 1\n\nassert.notStrictEqual(1, '1');\n// OK\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.notStrictEqual(1, 2);\n// OK\n\nassert.notStrictEqual(1, 1);\n// AssertionError [ERR_ASSERTION]: Expected \"actual\" to be strictly unequal to:\n//\n// 1\n\nassert.notStrictEqual(1, '1');\n// OK\n</code></pre>\nIf the values are strictly equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a\n<code>message</code> property set equal to the value of the <code>message</code> parameter. If the\n<code>message</code> parameter is undefined, a default error message is assigned. If the\n<code>message</code> parameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown\ninstead of the <code>AssertionError</code>."
 },
 {
 "textRaw": "`assert.ok(value[, message])`",
 "type": "method",
 "name": "ok",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v10.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/18319",
 "description": "The `assert.ok()` (no arguments) will now use a predefined error message."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`value` {any}",
 "name": "value",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Tests if <code>value</code> is truthy. It is equivalent to\n<code>assert.equal(!!value, true, message)</code>.\nIf <code>value</code> is not truthy, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a <code>message</code>\nproperty set equal to the value of the <code>message</code> parameter. If the <code>message</code>\nparameter is <code>undefined</code>, a default error message is assigned. If the <code>message</code>\nparameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown instead of the\n<code>AssertionError</code>.\nIf no arguments are passed in at all <code>message</code> will be set to the string:\n<code>'No value argument passed to `assert.ok()`'</code>.\nBe aware that in the <code>repl</code> the error message will be different to the one\nthrown in a file! See below for further details.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.ok(true);\n// OK\nassert.ok(1);\n// OK\n\nassert.ok();\n// AssertionError: No value argument passed to `assert.ok()`\n\nassert.ok(false, 'it\\'s false');\n// AssertionError: it's false\n\n// In the repl:\nassert.ok(typeof 123 === 'string');\n// AssertionError: false == true\n\n// In a file (e.g. test.js):\nassert.ok(typeof 123 === 'string');\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert.ok(typeof 123 === 'string')\n\nassert.ok(false);\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert.ok(false)\n\nassert.ok(0);\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert.ok(0)\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.ok(true);\n// OK\nassert.ok(1);\n// OK\n\nassert.ok();\n// AssertionError: No value argument passed to `assert.ok()`\n\nassert.ok(false, 'it\\'s false');\n// AssertionError: it's false\n\n// In the repl:\nassert.ok(typeof 123 === 'string');\n// AssertionError: false == true\n\n// In a file (e.g. test.js):\nassert.ok(typeof 123 === 'string');\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert.ok(typeof 123 === 'string')\n\nassert.ok(false);\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert.ok(false)\n\nassert.ok(0);\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert.ok(0)\n</code></pre>\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\n// Using `assert()` works the same:\nassert(0);\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert(0)\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert');\n\n// Using `assert()` works the same:\nassert(0);\n// AssertionError: The expression evaluated to a falsy value:\n//\n// assert(0)\n</code></pre>"
 },
 {
 "textRaw": "`assert.rejects(asyncFn[, error][, message])`",
 "type": "method",
 "name": "rejects",
 "meta": {
 "added": [
 "v10.0.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`asyncFn` {Function|Promise}",
 "name": "asyncFn",
 "type": "Function|Promise"
 },
 {
 "textRaw": "`error` {RegExp|Function|Object|Error}",
 "name": "error",
 "type": "RegExp|Function|Object|Error"
 },
 {
 "textRaw": "`message` {string}",
 "name": "message",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "Awaits the <code>asyncFn</code> promise or, if <code>asyncFn</code> is a function, immediately\ncalls the function and awaits the returned promise to complete. It will then\ncheck that the promise is rejected.\nIf <code>asyncFn</code> is a function and it throws an error synchronously,\n<code>assert.rejects()</code> will return a rejected <code>Promise</code> with that error. If the\nfunction does not return a promise, <code>assert.rejects()</code> will return a rejected\n<code>Promise</code> with an <a href=\"errors.html#err_invalid_return_value\"><code>ERR_INVALID_RETURN_VALUE</code></a> error. In both cases the error\nhandler is skipped.\nBesides the async nature to await the completion behaves identically to\n<a href=\"#assertthrowsfn-error-message\"><code>assert.throws()</code></a>.\nIf specified, <code>error</code> can be a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes\"><code>Class</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\"><code>RegExp</code></a>, a validation function,\nan object where each property will be tested for, or an instance of error where\neach property will be tested for including the non-enumerable <code>message</code> and\n<code>name</code> properties.\nIf specified, <code>message</code> will be the message provided by the <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>\nif the <code>asyncFn</code> fails to reject.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nawait assert.rejects(\n async () => {\n throw new TypeError('Wrong value');\n },\n {\n name: 'TypeError',\n message: 'Wrong value'\n }\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\n(async () => {\n await assert.rejects(\n async () => {\n throw new TypeError('Wrong value');\n },\n {\n name: 'TypeError',\n message: 'Wrong value'\n }\n );\n})();\n</code></pre>\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nawait assert.rejects(\n async () => {\n throw new TypeError('Wrong value');\n },\n (err) => {\n assert.strictEqual(err.name, 'TypeError');\n assert.strictEqual(err.message, 'Wrong value');\n return true;\n }\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\n(async () => {\n await assert.rejects(\n async () => {\n throw new TypeError('Wrong value');\n },\n (err) => {\n assert.strictEqual(err.name, 'TypeError');\n assert.strictEqual(err.message, 'Wrong value');\n return true;\n }\n );\n})();\n</code></pre>\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.rejects(\n Promise.reject(new Error('Wrong value')),\n Error\n).then(() => {\n // ...\n});\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.rejects(\n Promise.reject(new Error('Wrong value')),\n Error\n).then(() => {\n // ...\n});\n</code></pre>\n<code>error</code> cannot be a string. If a string is provided as the second\nargument, then <code>error</code> is assumed to be omitted and the string will be used for\n<code>message</code> instead. This can lead to easy-to-miss mistakes. Please read the\nexample in <a href=\"#assertthrowsfn-error-message\"><code>assert.throws()</code></a> carefully if using a string as the second\nargument gets considered."
 },
 {
 "textRaw": "`assert.strictEqual(actual, expected[, message])`",
 "type": "method",
 "name": "strictEqual",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v10.0.0",
 "pr-url": "https://github.com/nodejs/node/pull/17003",
 "description": "Used comparison changed from Strict Equality to `Object.is()`."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`actual` {any}",
 "name": "actual",
 "type": "any"
 },
 {
 "textRaw": "`expected` {any}",
 "name": "expected",
 "type": "any"
 },
 {
 "textRaw": "`message` {string|Error}",
 "name": "message",
 "type": "string|Error"
 }
 ]
 }
 ],
 "desc": "Tests strict equality between the <code>actual</code> and <code>expected</code> parameters as\ndetermined by <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\"><code>Object.is()</code></a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.strictEqual(1, 2);\n// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:\n//\n// 1 !== 2\n\nassert.strictEqual(1, 1);\n// OK\n\nassert.strictEqual('Hello foobar', 'Hello World!');\n// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:\n// + actual - expected\n//\n// + 'Hello foobar'\n// - 'Hello World!'\n// ^\n\nconst apples = 1;\nconst oranges = 2;\nassert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);\n// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2\n\nassert.strictEqual(1, '1', new TypeError('Inputs are not identical'));\n// TypeError: Inputs are not identical\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.strictEqual(1, 2);\n// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:\n//\n// 1 !== 2\n\nassert.strictEqual(1, 1);\n// OK\n\nassert.strictEqual('Hello foobar', 'Hello World!');\n// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:\n// + actual - expected\n//\n// + 'Hello foobar'\n// - 'Hello World!'\n// ^\n\nconst apples = 1;\nconst oranges = 2;\nassert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);\n// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2\n\nassert.strictEqual(1, '1', new TypeError('Inputs are not identical'));\n// TypeError: Inputs are not identical\n</code></pre>\nIf the values are not strictly equal, an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a> is thrown with a\n<code>message</code> property set equal to the value of the <code>message</code> parameter. If the\n<code>message</code> parameter is undefined, a default error message is assigned. If the\n<code>message</code> parameter is an instance of an <a href=\"errors.html#class-error\"><code>Error</code></a> then it will be thrown\ninstead of the <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>."
 },
 {
 "textRaw": "`assert.throws(fn[, error][, message])`",
 "type": "method",
 "name": "throws",
 "meta": {
 "added": [
 "v0.1.21"
 ],
 "changes": [
 {
 "version": "v10.2.0",
 "pr-url": "https://github.com/nodejs/node/pull/20485",
 "description": "The `error` parameter can be an object containing regular expressions now."
 },
 {
 "version": "v9.9.0",
 "pr-url": "https://github.com/nodejs/node/pull/17584",
 "description": "The `error` parameter can now be an object as well."
 },
 {
 "version": "v4.2.0",
 "pr-url": "https://github.com/nodejs/node/pull/3276",
 "description": "The `error` parameter can now be an arrow function."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`fn` {Function}",
 "name": "fn",
 "type": "Function"
 },
 {
 "textRaw": "`error` {RegExp|Function|Object|Error}",
 "name": "error",
 "type": "RegExp|Function|Object|Error"
 },
 {
 "textRaw": "`message` {string}",
 "name": "message",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "Expects the function <code>fn</code> to throw an error.\nIf specified, <code>error</code> can be a <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes\"><code>Class</code></a>, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\"><code>RegExp</code></a>, a validation function,\na validation object where each property will be tested for strict deep equality,\nor an instance of error where each property will be tested for strict deep\nequality including the non-enumerable <code>message</code> and <code>name</code> properties. When\nusing an object, it is also possible to use a regular expression, when\nvalidating against a string property. See below for examples.\nIf specified, <code>message</code> will be appended to the message provided by the\n<code>AssertionError</code> if the <code>fn</code> call fails to throw or in case the error validation\nfails.\nCustom validation object/error instance:\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nconst err = new TypeError('Wrong value');\nerr.code = 404;\nerr.foo = 'bar';\nerr.info = {\n nested: true,\n baz: 'text'\n};\nerr.reg = /abc/i;\n\nassert.throws(\n () => {\n throw err;\n },\n {\n name: 'TypeError',\n message: 'Wrong value',\n info: {\n nested: true,\n baz: 'text'\n }\n // Only properties on the validation object will be tested for.\n // Using nested objects requires all properties to be present. Otherwise\n // the validation is going to fail.\n }\n);\n\n// Using regular expressions to validate error properties:\nassert.throws(\n () => {\n throw err;\n },\n {\n // The `name` and `message` properties are strings and using regular\n // expressions on those will match against the string. If they fail, an\n // error is thrown.\n name: /^TypeError$/,\n message: /Wrong/,\n foo: 'bar',\n info: {\n nested: true,\n // It is not possible to use regular expressions for nested properties!\n baz: 'text'\n },\n // The `reg` property contains a regular expression and only if the\n // validation object contains an identical regular expression, it is going\n // to pass.\n reg: /abc/i\n }\n);\n\n// Fails due to the different `message` and `name` properties:\nassert.throws(\n () => {\n const otherErr = new Error('Not found');\n // Copy all enumerable properties from `err` to `otherErr`.\n for (const [key, value] of Object.entries(err)) {\n otherErr[key] = value;\n }\n throw otherErr;\n },\n // The error's `message` and `name` properties will also be checked when using\n // an error as validation object.\n err\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nconst err = new TypeError('Wrong value');\nerr.code = 404;\nerr.foo = 'bar';\nerr.info = {\n nested: true,\n baz: 'text'\n};\nerr.reg = /abc/i;\n\nassert.throws(\n () => {\n throw err;\n },\n {\n name: 'TypeError',\n message: 'Wrong value',\n info: {\n nested: true,\n baz: 'text'\n }\n // Only properties on the validation object will be tested for.\n // Using nested objects requires all properties to be present. Otherwise\n // the validation is going to fail.\n }\n);\n\n// Using regular expressions to validate error properties:\nassert.throws(\n () => {\n throw err;\n },\n {\n // The `name` and `message` properties are strings and using regular\n // expressions on those will match against the string. If they fail, an\n // error is thrown.\n name: /^TypeError$/,\n message: /Wrong/,\n foo: 'bar',\n info: {\n nested: true,\n // It is not possible to use regular expressions for nested properties!\n baz: 'text'\n },\n // The `reg` property contains a regular expression and only if the\n // validation object contains an identical regular expression, it is going\n // to pass.\n reg: /abc/i\n }\n);\n\n// Fails due to the different `message` and `name` properties:\nassert.throws(\n () => {\n const otherErr = new Error('Not found');\n // Copy all enumerable properties from `err` to `otherErr`.\n for (const [key, value] of Object.entries(err)) {\n otherErr[key] = value;\n }\n throw otherErr;\n },\n // The error's `message` and `name` properties will also be checked when using\n // an error as validation object.\n err\n);\n</code></pre>\nValidate instanceof using constructor:\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n Error\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n Error\n);\n</code></pre>\nValidate error message using <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\"><code>RegExp</code></a>:\nUsing a regular expression runs <code>.toString</code> on the error object, and will\ntherefore also include the error name.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n /^Error: Wrong value$/\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n /^Error: Wrong value$/\n);\n</code></pre>\nCustom error validation:\nThe function must return <code>true</code> to indicate all internal validations passed.\nIt will otherwise fail with an <a href=\"#class-assertassertionerror\"><code>AssertionError</code></a>.\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n (err) => {\n assert(err instanceof Error);\n assert(/value/.test(err));\n // Avoid returning anything from validation functions besides `true`.\n // Otherwise, it's not clear what part of the validation failed. Instead,\n // throw an error about the specific validation that failed (as done in this\n // example) and add as much helpful debugging information to that error as\n // possible.\n return true;\n },\n 'unexpected error'\n);\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nassert.throws(\n () => {\n throw new Error('Wrong value');\n },\n (err) => {\n assert(err instanceof Error);\n assert(/value/.test(err));\n // Avoid returning anything from validation functions besides `true`.\n // Otherwise, it's not clear what part of the validation failed. Instead,\n // throw an error about the specific validation that failed (as done in this\n // example) and add as much helpful debugging information to that error as\n // possible.\n return true;\n },\n 'unexpected error'\n);\n</code></pre>\n<code>error</code> cannot be a string. If a string is provided as the second\nargument, then <code>error</code> is assumed to be omitted and the string will be used for\n<code>message</code> instead. This can lead to easy-to-miss mistakes. Using the same\nmessage as the thrown error message is going to result in an\n<code>ERR_AMBIGUOUS_ARGUMENT</code> error. Please read the example below carefully if using\na string as the second argument gets considered:\n<pre><code class=\"language-mjs\">import assert from 'node:assert/strict';\n\nfunction throwingFirst() {\n throw new Error('First');\n}\n\nfunction throwingSecond() {\n throw new Error('Second');\n}\n\nfunction notThrowing() {}\n\n// The second argument is a string and the input function threw an Error.\n// The first case will not throw as it does not match for the error message\n// thrown by the input function!\nassert.throws(throwingFirst, 'Second');\n// In the next example the message has no benefit over the message from the\n// error and since it is not clear if the user intended to actually match\n// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.\nassert.throws(throwingSecond, 'Second');\n// TypeError [ERR_AMBIGUOUS_ARGUMENT]\n\n// The string is only used (as message) in case the function does not throw:\nassert.throws(notThrowing, 'Second');\n// AssertionError [ERR_ASSERTION]: Missing expected exception: Second\n\n// If it was intended to match for the error message do this instead:\n// It does not throw because the error messages match.\nassert.throws(throwingSecond, /Second$/);\n\n// If the error message does not match, an AssertionError is thrown.\nassert.throws(throwingFirst, /Second$/);\n// AssertionError [ERR_ASSERTION]\n</code></pre>\n<pre><code class=\"language-cjs\">const assert = require('node:assert/strict');\n\nfunction throwingFirst() {\n throw new Error('First');\n}\n\nfunction throwingSecond() {\n throw new Error('Second');\n}\n\nfunction notThrowing() {}\n\n// The second argument is a string and the input function threw an Error.\n// The first case will not throw as it does not match for the error message\n// thrown by the input function!\nassert.throws(throwingFirst, 'Second');\n// In the next example the message has no benefit over the message from the\n// error and since it is not clear if the user intended to actually match\n// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.\nassert.throws(throwingSecond, 'Second');\n// TypeError [ERR_AMBIGUOUS_ARGUMENT]\n\n// The string is only used (as message) in case the function does not throw:\nassert.throws(notThrowing, 'Second');\n// AssertionError [ERR_ASSERTION]: Missing expected exception: Second\n\n// If it was intended to match for the error message do this instead:\n// It does not throw because the error messages match.\nassert.throws(throwingSecond, /Second$/);\n\n// If the error message does not match, an AssertionError is thrown.\nassert.throws(throwingFirst, /Second$/);\n// AssertionError [ERR_ASSERTION]\n</code></pre>\nDue to the confusing error-prone notation, avoid a string as the second\nargument."
 }
 ],
 "type": "module",
 "displayName": "Assert"
 }
 ]
}

.	Edit
..	Edit
addons.html	Edit
addons.json	Edit
addons.md	Edit
all.html	Edit
all.json	Edit
assert.html	Edit
assert.json	Edit
assert.md	Edit
assets	Edit
async_context.html	Edit
async_context.json	Edit
async_context.md	Edit
async_hooks.html	Edit
async_hooks.json	Edit
async_hooks.md	Edit
buffer.html	Edit
buffer.json	Edit
buffer.md	Edit
child_process.html	Edit
child_process.json	Edit
child_process.md	Edit
cli.html	Edit
cli.json	Edit
cli.md	Edit
cluster.html	Edit
cluster.json	Edit
cluster.md	Edit
console.html	Edit
console.json	Edit
console.md	Edit
corepack.html	Edit
corepack.json	Edit
corepack.md	Edit
crypto.html	Edit
crypto.json	Edit
crypto.md	Edit
debugger.html	Edit
debugger.json	Edit
debugger.md	Edit
deprecations.html	Edit
deprecations.json	Edit
deprecations.md	Edit
dgram.html	Edit
dgram.json	Edit
dgram.md	Edit
diagnostics_channel.html	Edit
diagnostics_channel.json	Edit
diagnostics_channel.md	Edit
dns.html	Edit
dns.json	Edit
dns.md	Edit
documentation.html	Edit
documentation.json	Edit
documentation.md	Edit
domain.html	Edit
domain.json	Edit
domain.md	Edit
embedding.html	Edit
embedding.json	Edit
embedding.md	Edit
errors.html	Edit
errors.json	Edit
errors.md	Edit
esm.html	Edit
esm.json	Edit
esm.md	Edit
events.html	Edit
events.json	Edit
events.md	Edit
fs.html	Edit
fs.json	Edit
fs.md	Edit
globals.html	Edit
globals.json	Edit
globals.md	Edit
http.html	Edit
http.json	Edit
http.md	Edit
http2.html	Edit
http2.json	Edit
http2.md	Edit
https.html	Edit
https.json	Edit
https.md	Edit
index.html	Edit
index.json	Edit
index.md	Edit
inspector.html	Edit
inspector.json	Edit
inspector.md	Edit
intl.html	Edit
intl.json	Edit
intl.md	Edit
module.html	Edit
module.json	Edit
module.md	Edit
modules.html	Edit
modules.json	Edit
modules.md	Edit
n-api.html	Edit
n-api.json	Edit
n-api.md	Edit
net.html	Edit
net.json	Edit
net.md	Edit
os.html	Edit
os.json	Edit
os.md	Edit
packages.html	Edit
packages.json	Edit
packages.md	Edit
path.html	Edit
path.json	Edit
path.md	Edit
perf_hooks.html	Edit
perf_hooks.json	Edit
perf_hooks.md	Edit
permissions.html	Edit
permissions.json	Edit
permissions.md	Edit
policy.html	Edit
policy.json	Edit
policy.md	Edit
process.html	Edit
process.json	Edit
process.md	Edit
punycode.html	Edit
punycode.json	Edit
punycode.md	Edit
querystring.html	Edit
querystring.json	Edit
querystring.md	Edit
readline.html	Edit
readline.json	Edit
readline.md	Edit
repl.html	Edit
repl.json	Edit
repl.md	Edit
report.html	Edit
report.json	Edit
report.md	Edit
stream.html	Edit
stream.json	Edit
stream.md	Edit
string_decoder.html	Edit
string_decoder.json	Edit
string_decoder.md	Edit
synopsis.html	Edit
synopsis.json	Edit
synopsis.md	Edit
test.html	Edit
test.json	Edit
test.md	Edit
timers.html	Edit
timers.json	Edit
timers.md	Edit
tls.html	Edit
tls.json	Edit
tls.md	Edit
tracing.html	Edit
tracing.json	Edit
tracing.md	Edit
tty.html	Edit
tty.json	Edit
tty.md	Edit
url.html	Edit
url.json	Edit
url.md	Edit
util.html	Edit
util.json	Edit
util.md	Edit
v8.html	Edit
v8.json	Edit
v8.md	Edit
vm.html	Edit
vm.json	Edit
vm.md	Edit
wasi.html	Edit
wasi.json	Edit
wasi.md	Edit
webcrypto.html	Edit
webcrypto.json	Edit
webcrypto.md	Edit
webstreams.html	Edit
webstreams.json	Edit
webstreams.md	Edit
worker_threads.html	Edit
worker_threads.json	Edit
worker_threads.md	Edit
zlib.html	Edit
zlib.json	Edit
zlib.md	Edit